Coverage report

checker.js
var vowFs = require('vow-fs');
var Vow = require('vow');
var StringChecker = require('./string-checker');
var utils = require('util');
var path = require('path');
var NodeConfiguration = require('./config/node-configuration');
/**
 * Starts Code Style checking process.
 *
 * @name Checker
 */
Function (anonymous_1)
✓ Was calledvar Checker = function() {···
    StringChecker.apply(this, arguments);
};
var Checker = function() {
    StringChecker.apply(this, arguments);
};
utils.inherits(Checker, StringChecker);
/**
 * Loads configuration from JS Object. Activates and configures required rules.
 *
 * @param {Object} config
 */
Function (anonymous_2)
✓ Was calledChecker.prototype.configure = function(/*config*/) {···
    StringChecker.prototype.configure.apply(this, arguments);

    this._fileExtensions = this._configuration.getFileExtensions();
};
Checker.prototype.configure = function(/*config*/) {
    StringChecker.prototype.configure.apply(this, arguments);
    this._fileExtensions = this._configuration.getFileExtensions();
};
/**
 * Checks single file.
 *
 * @param {String} path
 * @returns {Promise * Errors}
 */
Function (anonymous_3)
✓ Was calledChecker.prototype.checkFile = function(path) {···
    if (this._configuration.isFileExcluded(path)) {
        return Vow.resolve(null);
    }

    return vowFs.read(path, 'utf8').then(function(data) {
        return this.checkString(data, path);
    }, this);
};
Checker.prototype.checkFile = function(path) {
Branch IfStatement
✓ Positive was executed (if)    if (this._configuration.isFileExcluded(path)) {···
        return Vow.resolve(null);
    }
✓ Negative was executed (else)    }···

    return vowFs.read(path, 'utf8').then(function(data) {
    if (this._configuration.isFileExcluded(path)) {
        return Vow.resolve(null);
    }
Function (anonymous_4)
✓ Was called    return vowFs.read(path, 'utf8').then(function(data) {···
        return this.checkString(data, path);
    }, this);
    return vowFs.read(path, 'utf8').then(function(data) {
        return this.checkString(data, path);
    }, this);
};
/**
 * Fixes single file.
 *
 * @param {String} path
 * @returns {Promise * Errors}
 */
Function (anonymous_5)
✓ Was calledChecker.prototype.fixFile = function(path) {···
    if (this._configuration.isFileExcluded(path)) {
        return Vow.resolve(null);
    }

    return vowFs.read(path, 'utf8').then(function(data) {
        var result = this.fixString(data, path);
        return vowFs.write(path, result.output).then(function() {
            return result.errors;
        });
    }, this);
};
Checker.prototype.fixFile = function(path) {
Branch IfStatement
✓ Positive was executed (if)    if (this._configuration.isFileExcluded(path)) {···
        return Vow.resolve(null);
    }
✓ Negative was executed (else)    }···

    return vowFs.read(path, 'utf8').then(function(data) {
    if (this._configuration.isFileExcluded(path)) {
        return Vow.resolve(null);
    }
Function (anonymous_6)
✓ Was called    return vowFs.read(path, 'utf8').then(function(data) {···
        var result = this.fixString(data, path);
        return vowFs.write(path, result.output).then(function() {
            return result.errors;
        });
    }, this);
    return vowFs.read(path, 'utf8').then(function(data) {
        var result = this.fixString(data, path);
Function (anonymous_7)
✓ Was called        return vowFs.write(path, result.output).then(function() {···
            return result.errors;
        });
        return vowFs.write(path, result.output).then(function() {
            return result.errors;
        });
    }, this);
};
/**
 * Checks directory recursively.
 *
 * @param {String} path
 * @returns {Promise * Error[]}
 */
Function (anonymous_8)
✓ Was calledChecker.prototype.checkDirectory = function(path) {···
    return this._processDirectory(path, this.checkFile.bind(this));
};
Checker.prototype.checkDirectory = function(path) {
    return this._processDirectory(path, this.checkFile.bind(this));
};
/**
 * Checks directory or file.
 *
 * @param {String} path
 * @returns {Promise * Error[]}
 */
Function (anonymous_9)
✓ Was calledChecker.prototype.checkPath = function(path) {···
    return this._processPath(path, this.checkFile.bind(this));
};
Checker.prototype.checkPath = function(path) {
    return this._processPath(path, this.checkFile.bind(this));
};
/**
 * Fixes directory or file.
 *
 * @param {String} path
 * @returns {Promise * Error[]}
 */
Function (anonymous_10)
✓ Was calledChecker.prototype.fixPath = function(path) {···
    return this._processPath(path, this.fixFile.bind(this));
};
Checker.prototype.fixPath = function(path) {
    return this._processPath(path, this.fixFile.bind(this));
};
/**
 * Processes directory recursively.
 *
 * @param {String} path
 * @param {Function} fileHandler
 * @returns {Promise * Error[]}
 */
Function (anonymous_11)
✓ Was calledChecker.prototype._processDirectory = function(path, fileHandler) {···
    return vowFs.listDir(path).then(function(filenames) {
        return Vow.all(filenames.map(function(filename) {
            var fullname = path + '/' + filename;

            if (this._configuration.isFileExcluded(fullname)) {
                return [];
            }

            return vowFs.stat(fullname).then(function(stat) {
                if (stat.isDirectory()) {
                    return this._processDirectory(fullname, fileHandler);
                }

                if (!this._hasCorrectExtension(fullname)) {
                    return [];
                }

                return Vow.when(fileHandler(fullname)).then(function(errors) {
                    if (errors) {
                        return errors;
                    }

                    return [];
                });
            }, this);
        }, this)).then(function(results) {
            return [].concat.apply([], results);
        });
    }, this);
};
Checker.prototype._processDirectory = function(path, fileHandler) {
Function (anonymous_12)
✓ Was called    return vowFs.listDir(path).then(function(filenames) {···
        return Vow.all(filenames.map(function(filename) {
            var fullname = path + '/' + filename;

            if (this._configuration.isFileExcluded(fullname)) {
                return [];
            }

            return vowFs.stat(fullname).then(function(stat) {
                if (stat.isDirectory()) {
                    return this._processDirectory(fullname, fileHandler);
                }

                if (!this._hasCorrectExtension(fullname)) {
                    return [];
                }

                return Vow.when(fileHandler(fullname)).then(function(errors) {
                    if (errors) {
                        return errors;
                    }

                    return [];
                });
            }, this);
        }, this)).then(function(results) {
            return [].concat.apply([], results);
        });
    }, this);
    return vowFs.listDir(path).then(function(filenames) {
Function (anonymous_13)
✓ Was called        return Vow.all(filenames.map(function(filename) {···
            var fullname = path + '/' + filename;

            if (this._configuration.isFileExcluded(fullname)) {
                return [];
            }

            return vowFs.stat(fullname).then(function(stat) {
                if (stat.isDirectory()) {
                    return this._processDirectory(fullname, fileHandler);
                }

                if (!this._hasCorrectExtension(fullname)) {
                    return [];
                }

                return Vow.when(fileHandler(fullname)).then(function(errors) {
                    if (errors) {
                        return errors;
                    }

                    return [];
                });
            }, this);
        }, this)).then(function(results) {
        return Vow.all(filenames.map(function(filename) {
            var fullname = path + '/' + filename;
Branch IfStatement
✓ Positive was executed (if)            if (this._configuration.isFileExcluded(fullname)) {···
                return [];
            }
✓ Negative was executed (else)            }···

            return vowFs.stat(fullname).then(function(stat) {
            if (this._configuration.isFileExcluded(fullname)) {
                return [];
            }
Function (anonymous_14)
✓ Was called            return vowFs.stat(fullname).then(function(stat) {···
                if (stat.isDirectory()) {
                    return this._processDirectory(fullname, fileHandler);
                }

                if (!this._hasCorrectExtension(fullname)) {
                    return [];
                }

                return Vow.when(fileHandler(fullname)).then(function(errors) {
                    if (errors) {
                        return errors;
                    }

                    return [];
                });
            }, this);
            return vowFs.stat(fullname).then(function(stat) {
Branch IfStatement
✓ Positive was executed (if)                if (stat.isDirectory()) {···
                    return this._processDirectory(fullname, fileHandler);
                }
✓ Negative was executed (else)                }···

                if (!this._hasCorrectExtension(fullname)) {
                if (stat.isDirectory()) {
                    return this._processDirectory(fullname, fileHandler);
                }
Branch IfStatement
✓ Positive was executed (if)                if (!this._hasCorrectExtension(fullname)) {···
                    return [];
                }
✓ Negative was executed (else)                }···

                return Vow.when(fileHandler(fullname)).then(function(errors) {
                if (!this._hasCorrectExtension(fullname)) {
                    return [];
                }
Function (anonymous_15)
✓ Was called                return Vow.when(fileHandler(fullname)).then(function(errors) {···
                    if (errors) {
                        return errors;
                    }

                    return [];
                });
                return Vow.when(fileHandler(fullname)).then(function(errors) {
Branch IfStatement
✓ Positive was executed (if)                    if (errors) {···
                        return errors;
                    }
✗ Negative was not executed (else)                    }···

                    return [];
                    if (errors) {
                        return errors;
                    }
                    return [];
                });
            }, this);
Function (anonymous_16)
✓ Was called        }, this)).then(function(results) {···
            return [].concat.apply([], results);
        });
        }, this)).then(function(results) {
            return [].concat.apply([], results);
        });
    }, this);
};
/**
 * Processes directory or file.
 *
 * @param {String} path
 * @param {Function} fileHandler
 * @returns {Promise * Error[]}
 */
Function (anonymous_17)
✓ Was calledChecker.prototype._processPath = function(path, fileHandler) {···
    path = path.replace(/\/$/, '');
    var _this = this;

    return vowFs.exists(path).then(function(exists) {
        if (!exists) {
            throw new Error('Path ' + path + ' was not found.');
        }

        return vowFs.stat(path).then(function(stat) {
            if (stat.isDirectory()) {
                return _this._processDirectory(path, fileHandler);
            }

            return fileHandler(path).then(function(errors) {
                if (errors) {
                    return [errors];
                }

                return [];
            });
        });
    });
};
Checker.prototype._processPath = function(path, fileHandler) {
    path = path.replace(/\/$/, '');
    var _this = this;
Function (anonymous_18)
✓ Was called    return vowFs.exists(path).then(function(exists) {···
        if (!exists) {
            throw new Error('Path ' + path + ' was not found.');
        }

        return vowFs.stat(path).then(function(stat) {
            if (stat.isDirectory()) {
                return _this._processDirectory(path, fileHandler);
            }

            return fileHandler(path).then(function(errors) {
                if (errors) {
                    return [errors];
                }

                return [];
            });
        });
    });
    return vowFs.exists(path).then(function(exists) {
Branch IfStatement
✗ Positive was not executed (if)        if (!exists) {···
            throw new Error('Path ' + path + ' was not found.');
        }
✓ Negative was executed (else)        }···

        return vowFs.stat(path).then(function(stat) {
        if (!exists) {
            throw new Error('Path ' + path + ' was not found.');
        }
Function (anonymous_19)
✓ Was called        return vowFs.stat(path).then(function(stat) {···
            if (stat.isDirectory()) {
                return _this._processDirectory(path, fileHandler);
            }

            return fileHandler(path).then(function(errors) {
                if (errors) {
                    return [errors];
                }

                return [];
            });
        });
        return vowFs.stat(path).then(function(stat) {
Branch IfStatement
✓ Positive was executed (if)            if (stat.isDirectory()) {···
                return _this._processDirectory(path, fileHandler);
            }
✓ Negative was executed (else)            }···

            return fileHandler(path).then(function(errors) {
            if (stat.isDirectory()) {
                return _this._processDirectory(path, fileHandler);
            }
Function (anonymous_20)
✓ Was called            return fileHandler(path).then(function(errors) {···
                if (errors) {
                    return [errors];
                }

                return [];
            });
            return fileHandler(path).then(function(errors) {
Branch IfStatement
✓ Positive was executed (if)                if (errors) {···
                    return [errors];
                }
✗ Negative was not executed (else)                }···

                return [];
                if (errors) {
                    return [errors];
                }
                return [];
            });
        });
    });
};
/**
 * Checks stdin for input
 *
 * @returns {Promise}
 */
Function (anonymous_21)
✓ Was calledChecker.prototype.checkStdin = function() {···
    return this._processStdin(this.checkString.bind(this));
};
Checker.prototype.checkStdin = function() {
    return this._processStdin(this.checkString.bind(this));
};
/**
 * Fixes stdin input
 *
 * @returns {Promise}
 */
Function (anonymous_22)
✓ Was calledChecker.prototype.fixStdin = function() {···
    return this._processStdin(this.fixString.bind(this));
};
Checker.prototype.fixStdin = function() {
    return this._processStdin(this.fixString.bind(this));
};
/**
 *
 * @param {Function} stdinHandler
 * @returns {Promise}
 */
Function (anonymous_23)
✓ Was calledChecker.prototype._processStdin = function(stdinHandler) {···
    var stdInput = [];
    var deferred = Vow.defer();

    process.stdin.setEncoding('utf8');

    process.stdin.on('data', function(chunk) {
        stdInput.push(chunk);
    });

    process.stdin.on('end', function() {
        deferred.resolve(stdinHandler(stdInput.join('')));
    });

    return deferred.promise();
};
Checker.prototype._processStdin = function(stdinHandler) {
    var stdInput = [];
    var deferred = Vow.defer();
    process.stdin.setEncoding('utf8');
Function (anonymous_24)
✓ Was called    process.stdin.on('data', function(chunk) {···
        stdInput.push(chunk);
    });
    process.stdin.on('data', function(chunk) {
        stdInput.push(chunk);
    });
Function (anonymous_25)
✓ Was called    process.stdin.on('end', function() {···
        deferred.resolve(stdinHandler(stdInput.join('')));
    });
    process.stdin.on('end', function() {
        deferred.resolve(stdinHandler(stdInput.join('')));
    });
    return deferred.promise();
};
/**
 * Returns true if the file extension matches a file extension to process.
 *
 * @returns {Boolean}
 */
Function (anonymous_26)
✓ Was calledChecker.prototype._hasCorrectExtension = function(testPath) {···
    var extension = path.extname(testPath).toLowerCase();
    var basename = path.basename(testPath).toLowerCase();

    return !(
        this._fileExtensions.indexOf(extension) < 0 &&
        this._fileExtensions.indexOf(basename) < 0 &&
        this._fileExtensions.indexOf('*') < 0
    );
};
Checker.prototype._hasCorrectExtension = function(testPath) {
    var extension = path.extname(testPath).toLowerCase();
    var basename = path.basename(testPath).toLowerCase();
    return !(
Branch LogicalExpression
✓ Was returned        this._fileExtensions.indexOf('*') < 0
✓ Was returned        this._fileExtensions.indexOf(extension) < 0 &&···
        this._fileExtensions.indexOf(basename) < 0 &&
Branch LogicalExpression
✓ Was returned        this._fileExtensions.indexOf(basename) < 0 &&
✓ Was returned        this._fileExtensions.indexOf(extension) < 0 &&
        this._fileExtensions.indexOf(extension) < 0 &&
        this._fileExtensions.indexOf(basename) < 0 &&
        this._fileExtensions.indexOf('*') < 0
    );
};
/**
 * Returns new configuration instance.
 *
 * @protected
 * @returns {Configuration}
 */
Function (anonymous_27)
✓ Was calledChecker.prototype._createConfiguration = function() {···
    return new NodeConfiguration();
};
Checker.prototype._createConfiguration = function() {
    return new NodeConfiguration();
};
module.exports = Checker;

Function (anonymous_1)
✓ Was called	var Checker = function() {··· StringChecker.apply(this, arguments); };

Function (anonymous_2)
✓ Was called	Checker.prototype.configure = function(/config/) {··· StringChecker.prototype.configure.apply(this, arguments); this._fileExtensions = this._configuration.getFileExtensions(); };

Function (anonymous_3)
✓ Was called	Checker.prototype.checkFile = function(path) {··· if (this._configuration.isFileExcluded(path)) { return Vow.resolve(null); } return vowFs.read(path, 'utf8').then(function(data) { return this.checkString(data, path); }, this); };

Branch IfStatement
✓ Positive was executed (if)	if (this._configuration.isFileExcluded(path)) {··· return Vow.resolve(null); }
✓ Negative was executed (else)	}··· return vowFs.read(path, 'utf8').then(function(data) {

Function (anonymous_4)
✓ Was called	return vowFs.read(path, 'utf8').then(function(data) {··· return this.checkString(data, path); }, this);

Function (anonymous_5)
✓ Was called	Checker.prototype.fixFile = function(path) {··· if (this._configuration.isFileExcluded(path)) { return Vow.resolve(null); } return vowFs.read(path, 'utf8').then(function(data) { var result = this.fixString(data, path); return vowFs.write(path, result.output).then(function() { return result.errors; }); }, this); };

Branch IfStatement
✓ Positive was executed (if)	if (this._configuration.isFileExcluded(path)) {··· return Vow.resolve(null); }
✓ Negative was executed (else)	}··· return vowFs.read(path, 'utf8').then(function(data) {

Function (anonymous_6)
✓ Was called	return vowFs.read(path, 'utf8').then(function(data) {··· var result = this.fixString(data, path); return vowFs.write(path, result.output).then(function() { return result.errors; }); }, this);

Function (anonymous_7)
✓ Was called	return vowFs.write(path, result.output).then(function() {··· return result.errors; });

Function (anonymous_8)
✓ Was called	Checker.prototype.checkDirectory = function(path) {··· return this._processDirectory(path, this.checkFile.bind(this)); };

Function (anonymous_9)
✓ Was called	Checker.prototype.checkPath = function(path) {··· return this._processPath(path, this.checkFile.bind(this)); };

Function (anonymous_10)
✓ Was called	Checker.prototype.fixPath = function(path) {··· return this._processPath(path, this.fixFile.bind(this)); };

Function (anonymous_11)
✓ Was called	Checker.prototype._processDirectory = function(path, fileHandler) {··· return vowFs.listDir(path).then(function(filenames) { return Vow.all(filenames.map(function(filename) { var fullname = path + '/' + filename; if (this._configuration.isFileExcluded(fullname)) { return []; } return vowFs.stat(fullname).then(function(stat) { if (stat.isDirectory()) { return this._processDirectory(fullname, fileHandler); } if (!this._hasCorrectExtension(fullname)) { return []; } return Vow.when(fileHandler(fullname)).then(function(errors) { if (errors) { return errors; } return []; }); }, this); }, this)).then(function(results) { return [].concat.apply([], results); }); }, this); };

Function (anonymous_12)
✓ Was called	return vowFs.listDir(path).then(function(filenames) {··· return Vow.all(filenames.map(function(filename) { var fullname = path + '/' + filename; if (this._configuration.isFileExcluded(fullname)) { return []; } return vowFs.stat(fullname).then(function(stat) { if (stat.isDirectory()) { return this._processDirectory(fullname, fileHandler); } if (!this._hasCorrectExtension(fullname)) { return []; } return Vow.when(fileHandler(fullname)).then(function(errors) { if (errors) { return errors; } return []; }); }, this); }, this)).then(function(results) { return [].concat.apply([], results); }); }, this);

Function (anonymous_13)
✓ Was called	return Vow.all(filenames.map(function(filename) {··· var fullname = path + '/' + filename; if (this._configuration.isFileExcluded(fullname)) { return []; } return vowFs.stat(fullname).then(function(stat) { if (stat.isDirectory()) { return this._processDirectory(fullname, fileHandler); } if (!this._hasCorrectExtension(fullname)) { return []; } return Vow.when(fileHandler(fullname)).then(function(errors) { if (errors) { return errors; } return []; }); }, this); }, this)).then(function(results) {

Branch IfStatement
✓ Positive was executed (if)	if (this._configuration.isFileExcluded(fullname)) {··· return []; }
✓ Negative was executed (else)	}··· return vowFs.stat(fullname).then(function(stat) {

Function (anonymous_14)
✓ Was called	return vowFs.stat(fullname).then(function(stat) {··· if (stat.isDirectory()) { return this._processDirectory(fullname, fileHandler); } if (!this._hasCorrectExtension(fullname)) { return []; } return Vow.when(fileHandler(fullname)).then(function(errors) { if (errors) { return errors; } return []; }); }, this);

Branch IfStatement
✓ Positive was executed (if)	if (stat.isDirectory()) {··· return this._processDirectory(fullname, fileHandler); }
✓ Negative was executed (else)	}··· if (!this._hasCorrectExtension(fullname)) {

Branch IfStatement
✓ Positive was executed (if)	if (!this._hasCorrectExtension(fullname)) {··· return []; }
✓ Negative was executed (else)	}··· return Vow.when(fileHandler(fullname)).then(function(errors) {

Function (anonymous_15)
✓ Was called	return Vow.when(fileHandler(fullname)).then(function(errors) {··· if (errors) { return errors; } return []; });

Branch IfStatement
✓ Positive was executed (if)	if (errors) {··· return errors; }
✗ Negative was not executed (else)	}··· return [];

Function (anonymous_16)
✓ Was called	}, this)).then(function(results) {··· return [].concat.apply([], results); });

Function (anonymous_17)
✓ Was called	Checker.prototype._processPath = function(path, fileHandler) {··· path = path.replace(/\/$/, ''); var _this = this; return vowFs.exists(path).then(function(exists) { if (!exists) { throw new Error('Path ' + path + ' was not found.'); } return vowFs.stat(path).then(function(stat) { if (stat.isDirectory()) { return _this._processDirectory(path, fileHandler); } return fileHandler(path).then(function(errors) { if (errors) { return [errors]; } return []; }); }); }); };

Function (anonymous_18)
✓ Was called	return vowFs.exists(path).then(function(exists) {··· if (!exists) { throw new Error('Path ' + path + ' was not found.'); } return vowFs.stat(path).then(function(stat) { if (stat.isDirectory()) { return _this._processDirectory(path, fileHandler); } return fileHandler(path).then(function(errors) { if (errors) { return [errors]; } return []; }); }); });

Branch IfStatement
✗ Positive was not executed (if)	if (!exists) {··· throw new Error('Path ' + path + ' was not found.'); }
✓ Negative was executed (else)	}··· return vowFs.stat(path).then(function(stat) {

Function (anonymous_19)
✓ Was called	return vowFs.stat(path).then(function(stat) {··· if (stat.isDirectory()) { return _this._processDirectory(path, fileHandler); } return fileHandler(path).then(function(errors) { if (errors) { return [errors]; } return []; }); });

Branch IfStatement
✓ Positive was executed (if)	if (stat.isDirectory()) {··· return _this._processDirectory(path, fileHandler); }
✓ Negative was executed (else)	}··· return fileHandler(path).then(function(errors) {

Function (anonymous_20)
✓ Was called	return fileHandler(path).then(function(errors) {··· if (errors) { return [errors]; } return []; });

Branch IfStatement
✓ Positive was executed (if)	if (errors) {··· return [errors]; }
✗ Negative was not executed (else)	}··· return [];

Function (anonymous_21)
✓ Was called	Checker.prototype.checkStdin = function() {··· return this._processStdin(this.checkString.bind(this)); };

Function (anonymous_22)
✓ Was called	Checker.prototype.fixStdin = function() {··· return this._processStdin(this.fixString.bind(this)); };

Function (anonymous_23)
✓ Was called	Checker.prototype._processStdin = function(stdinHandler) {··· var stdInput = []; var deferred = Vow.defer(); process.stdin.setEncoding('utf8'); process.stdin.on('data', function(chunk) { stdInput.push(chunk); }); process.stdin.on('end', function() { deferred.resolve(stdinHandler(stdInput.join(''))); }); return deferred.promise(); };

Function (anonymous_24)
✓ Was called	process.stdin.on('data', function(chunk) {··· stdInput.push(chunk); });

Function (anonymous_25)
✓ Was called	process.stdin.on('end', function() {··· deferred.resolve(stdinHandler(stdInput.join(''))); });

Function (anonymous_26)
✓ Was called	Checker.prototype._hasCorrectExtension = function(testPath) {··· var extension = path.extname(testPath).toLowerCase(); var basename = path.basename(testPath).toLowerCase(); return !( this._fileExtensions.indexOf(extension) < 0 && this._fileExtensions.indexOf(basename) < 0 && this._fileExtensions.indexOf('*') < 0 ); };

Branch LogicalExpression
✓ Was returned	this._fileExtensions.indexOf('*') < 0
✓ Was returned	this._fileExtensions.indexOf(extension) < 0 &&··· this._fileExtensions.indexOf(basename) < 0 &&

Branch LogicalExpression
✓ Was returned	this._fileExtensions.indexOf(basename) < 0 &&
✓ Was returned	this._fileExtensions.indexOf(extension) < 0 &&

Function (anonymous_27)
✓ Was called	Checker.prototype._createConfiguration = function() {··· return new NodeConfiguration(); };

string-checker.js
var defaultEsprima = require('esprima');
var harmonyEsprima = require('esprima-harmony-jscs');
var Errors = require('./errors');
var JsFile = require('./js-file');
var Configuration = require('./config/configuration');
var MAX_FIX_ATTEMPTS = 5;
/**
 * Starts Code Style checking process.
 *
 * @name StringChecker
 *
 * Following params are deprecated, should be removed in 2.0
 * @param {Boolean|Object} options either a boolean flag representing verbosity (deprecated), or an options object
 * @param {Boolean} options.verbose true adds the rule name to the error messages it produces, false does not
 * @param {Boolean} options.esnext true attempts to parse the code as es6, false does not
 * @param {Object} options.esprima if provided, will be used to parse source code instead of the built-in esprima parser
 */
Function (anonymous_28)
✓ Was calledvar StringChecker = function(options) {···
    this._configuredRules = [];

    this._errorsFound = 0;
    this._maxErrorsExceeded = false;

    this._configuration = this._createConfiguration();
    this._configuration.registerDefaultPresets();

    if (typeof options === 'boolean') {
        this._verbose = options;
    } else {
        options = options || {};
        this._verbose = options.verbose || false;
        this._esprima = options.esprima || (options.esnext ? harmonyEsprima : defaultEsprima);
    }
};
var StringChecker = function(options) {
    this._configuredRules = [];
    this._errorsFound = 0;
    this._maxErrorsExceeded = false;
    this._configuration = this._createConfiguration();
    this._configuration.registerDefaultPresets();
Branch IfStatement
✗ Positive was not executed (if)    if (typeof options === 'boolean') {···
        this._verbose = options;
    } else {
✓ Negative was executed (else)    } else {···
        options = options || {};
        this._verbose = options.verbose || false;
        this._esprima = options.esprima || (options.esnext ? harmonyEsprima : defaultEsprima);
    }
    if (typeof options === 'boolean') {
        this._verbose = options;
    } else {
Branch LogicalExpression
✓ Was returned        options = options || {};
✓ Was returned        options = options || {};
        options = options || {};
Branch LogicalExpression
✓ Was returned        this._verbose = options.verbose || false;
✓ Was returned        this._verbose = options.verbose || false;
        this._verbose = options.verbose || false;
Branch LogicalExpression
✓ Was returned        this._esprima = options.esprima || (options.esnext ? harmonyEsprima : defaultEsprima);
✓ Was returned        this._esprima = options.esprima || (options.esnext ? harmonyEsprima : defaultEsprima);
Branch ConditionalExpression
✓ Positive was returned (? ...)        this._esprima = options.esprima || (options.esnext ? harmonyEsprima : defaultEsprima);
✓ Negative was returned (: ...)        this._esprima = options.esprima || (options.esnext ? harmonyEsprima : defaultEsprima);
        this._esprima = options.esprima || (options.esnext ? harmonyEsprima : defaultEsprima);
    }
};
StringChecker.prototype = {
    /**
     * Registers single Code Style checking rule.
     *
     * @param {Rule} rule
     */
Function (anonymous_29)
✓ Was called    registerRule: function(rule) {···
        this._configuration.registerRule(rule);
    },
    registerRule: function(rule) {
        this._configuration.registerRule(rule);
    },
    /**
     * Registers built-in Code Style checking rules.
     */
Function (anonymous_30)
✓ Was called    registerDefaultRules: function() {···
        this._configuration.registerDefaultRules();
    },
    registerDefaultRules: function() {
        this._configuration.registerDefaultRules();
    },
    /**
     * Get processed config.
     *
     * @return {Object}
     */
Function (anonymous_31)
✗ Was not called    getProcessedConfig: function() {···
        return this._configuration.getProcessedConfig();
    },
    getProcessedConfig: function() {
        return this._configuration.getProcessedConfig();
    },
    /**
     * Loads configuration from JS Object. Activates and configures required rules.
     *
     * @param {Object} config
     */
Function (anonymous_32)
✓ Was called    configure: function(config) {···
        this._configuration.load(config);

        if (this._configuration.hasCustomEsprima()) {
            this._esprima = this._configuration.getCustomEsprima();
        } else if (this._configuration.isESNextEnabled()) {
            this._esprima = harmonyEsprima;
        }

        if (this._verbose === false) {
            this._verbose = this._configuration.getVerbose();
        }

        this._configuredRules = this._configuration.getConfiguredRules();
        this._maxErrors = this._configuration.getMaxErrors();
    },
    configure: function(config) {
        this._configuration.load(config);
Branch IfStatement
✗ Positive was not executed (if)        if (this._configuration.hasCustomEsprima()) {···
            this._esprima = this._configuration.getCustomEsprima();
        } else if (this._configuration.isESNextEnabled()) {
✓ Negative was executed (else)        } else if (this._configuration.isESNextEnabled()) {···
            this._esprima = harmonyEsprima;
        }
        if (this._configuration.hasCustomEsprima()) {
            this._esprima = this._configuration.getCustomEsprima();
Branch IfStatement
✓ Positive was executed (if)        } else if (this._configuration.isESNextEnabled()) {···
            this._esprima = harmonyEsprima;
        }
✓ Negative was executed (else)        }···

        if (this._verbose === false) {
        } else if (this._configuration.isESNextEnabled()) {
            this._esprima = harmonyEsprima;
        }
Branch IfStatement
✓ Positive was executed (if)        if (this._verbose === false) {···
            this._verbose = this._configuration.getVerbose();
        }
✓ Negative was executed (else)        }···

        this._configuredRules = this._configuration.getConfiguredRules();
        if (this._verbose === false) {
            this._verbose = this._configuration.getVerbose();
        }
        this._configuredRules = this._configuration.getConfiguredRules();
        this._maxErrors = this._configuration.getMaxErrors();
    },
    /**
     * Checks file provided with a string.
     * @param {String} source
     * @param {String} [filename='input']
     * @returns {Errors}
     */
Function (anonymous_33)
✓ Was called    checkString: function(source, filename) {···
        filename = filename || 'input';

        var sourceTree;
        var parseError;

        try {
            sourceTree = JsFile.parse(source, this._esprima, this._configuration.getEsprimaOptions());
        } catch (e) {
            parseError = e;
        }

        var file = this._createJsFileInstance(filename, source, sourceTree);

        var errors = new Errors(file, this._verbose);

        if (this._maxErrorsExceeded) {
            return errors;
        }

        if (parseError) {
            this._addParseError(errors, parseError);
            return errors;
        }

        this._checkJsFile(file, errors);

        return errors;
    },
    checkString: function(source, filename) {
Branch LogicalExpression
✓ Was returned        filename = filename || 'input';
✓ Was returned        filename = filename || 'input';
        filename = filename || 'input';
        var sourceTree;
        var parseError;
        try {
            sourceTree = JsFile.parse(source, this._esprima, this._configuration.getEsprimaOptions());
        } catch (e) {
            parseError = e;
        }
        var file = this._createJsFileInstance(filename, source, sourceTree);
        var errors = new Errors(file, this._verbose);
Branch IfStatement
✓ Positive was executed (if)        if (this._maxErrorsExceeded) {···
            return errors;
        }
✓ Negative was executed (else)        }···

        if (parseError) {
        if (this._maxErrorsExceeded) {
            return errors;
        }
Branch IfStatement
✓ Positive was executed (if)        if (parseError) {···
            this._addParseError(errors, parseError);
            return errors;
        }
✓ Negative was executed (else)        }···

        this._checkJsFile(file, errors);
        if (parseError) {
            this._addParseError(errors, parseError);
            return errors;
        }
        this._checkJsFile(file, errors);
        return errors;
    },
    /**
     * Checks a file specified using JsFile instance.
     * Fills Errors instance with validation errors.
     *
     * @param {JsFile} file
     * @param {Errors} errors
     * @private
     */
Function (anonymous_34)
✓ Was called    _checkJsFile: function(file, errors) {···
        if (this._maxErrorsExceeded) {
            return;
        }

        var errorFilter = this._configuration.getErrorFilter();

        this._configuredRules.forEach(function(rule) {
            errors.setCurrentRule(rule.getOptionName());

            try {
                rule.check(file, errors);
            } catch (e) {
                errors.add('Error running rule ' + rule.getOptionName() + ': ' +
                    'This is an issue with JSCS and not your codebase.\n' +
                    'Please file an issue (with the stack trace below) at: ' +
                    'https://github.com/jscs-dev/node-jscs/issues/new\n' +
                    e.stack, 1, 0);
            }
        }, this);

        this._configuration.getUnsupportedRuleNames().forEach(function(rulename) {
            errors.add('Unsupported rule: ' + rulename, 1, 0);
        });

        // sort errors list to show errors as they appear in source
        errors.getErrorList().sort(function(a, b) {
            return (a.line - b.line) || (a.column - b.column);
        });

        if (errorFilter) {
            errors.filter(errorFilter);
        }

        if (this._maxErrorsEnabled()) {
            this._maxErrorsExceeded = this._errorsFound + errors.getErrorCount() > this._maxErrors;
            errors.stripErrorList(Math.max(0, this._maxErrors - this._errorsFound));
        }

        this._errorsFound += errors.getErrorCount();
    },
    _checkJsFile: function(file, errors) {
Branch IfStatement
✗ Positive was not executed (if)        if (this._maxErrorsExceeded) {···
            return;
        }
✓ Negative was executed (else)        }···

        var errorFilter = this._configuration.getErrorFilter();
        if (this._maxErrorsExceeded) {
            return;
        }
        var errorFilter = this._configuration.getErrorFilter();
Function (anonymous_35)
✓ Was called        this._configuredRules.forEach(function(rule) {···
            errors.setCurrentRule(rule.getOptionName());

            try {
                rule.check(file, errors);
            } catch (e) {
                errors.add('Error running rule ' + rule.getOptionName() + ': ' +
                    'This is an issue with JSCS and not your codebase.\n' +
                    'Please file an issue (with the stack trace below) at: ' +
                    'https://github.com/jscs-dev/node-jscs/issues/new\n' +
                    e.stack, 1, 0);
            }
        }, this);
        this._configuredRules.forEach(function(rule) {
            errors.setCurrentRule(rule.getOptionName());
            try {
                rule.check(file, errors);
            } catch (e) {
                errors.add('Error running rule ' + rule.getOptionName() + ': ' +
                    'This is an issue with JSCS and not your codebase.\n' +
                    'Please file an issue (with the stack trace below) at: ' +
                    'https://github.com/jscs-dev/node-jscs/issues/new\n' +
                    e.stack, 1, 0);
            }
        }, this);
Function (anonymous_36)
✓ Was called        this._configuration.getUnsupportedRuleNames().forEach(function(rulename) {···
            errors.add('Unsupported rule: ' + rulename, 1, 0);
        });
        this._configuration.getUnsupportedRuleNames().forEach(function(rulename) {
            errors.add('Unsupported rule: ' + rulename, 1, 0);
        });
        // sort errors list to show errors as they appear in source
Function (anonymous_37)
✓ Was called        errors.getErrorList().sort(function(a, b) {···
            return (a.line - b.line) || (a.column - b.column);
        });
        errors.getErrorList().sort(function(a, b) {
Branch LogicalExpression
✓ Was returned            return (a.line - b.line) || (a.column - b.column);
✓ Was returned            return (a.line - b.line) || (a.column - b.column);
            return (a.line - b.line) || (a.column - b.column);
        });
Branch IfStatement
✓ Positive was executed (if)        if (errorFilter) {···
            errors.filter(errorFilter);
        }
✓ Negative was executed (else)        }···

        if (this._maxErrorsEnabled()) {
        if (errorFilter) {
            errors.filter(errorFilter);
        }
Branch IfStatement
✓ Positive was executed (if)        if (this._maxErrorsEnabled()) {···
            this._maxErrorsExceeded = this._errorsFound + errors.getErrorCount() > this._maxErrors;
            errors.stripErrorList(Math.max(0, this._maxErrors - this._errorsFound));
        }
✓ Negative was executed (else)        }···

        this._errorsFound += errors.getErrorCount();
        if (this._maxErrorsEnabled()) {
            this._maxErrorsExceeded = this._errorsFound + errors.getErrorCount() > this._maxErrors;
            errors.stripErrorList(Math.max(0, this._maxErrors - this._errorsFound));
        }
        this._errorsFound += errors.getErrorCount();
    },
    /**
     * Adds parse error to the error list.
     *
     * @param {Errors} errors
     * @param {Error} parseError
     * @private
     */
Function (anonymous_38)
✓ Was called    _addParseError: function(errors, parseError) {···
        if (this._maxErrorsExceeded) {
            return;
        }

        errors.setCurrentRule('parseError');
        errors.add(parseError.description, parseError.lineNumber, parseError.column);

        if (this._maxErrorsEnabled()) {
            this._errorsFound += 1;
            this._maxErrorsExceeded = this._errorsFound >= this._maxErrors;
        }
    },
    _addParseError: function(errors, parseError) {
Branch IfStatement
✗ Positive was not executed (if)        if (this._maxErrorsExceeded) {···
            return;
        }
✓ Negative was executed (else)        }···

        errors.setCurrentRule('parseError');
        if (this._maxErrorsExceeded) {
            return;
        }
        errors.setCurrentRule('parseError');
        errors.add(parseError.description, parseError.lineNumber, parseError.column);
Branch IfStatement
✗ Positive was not executed (if)        if (this._maxErrorsEnabled()) {···
            this._errorsFound += 1;
            this._maxErrorsExceeded = this._errorsFound >= this._maxErrors;
        }
✓ Negative was executed (else)        }···
    },
        if (this._maxErrorsEnabled()) {
            this._errorsFound += 1;
            this._maxErrorsExceeded = this._errorsFound >= this._maxErrors;
        }
    },
    /**
     * Creates configured JsFile instance.
     *
     * @param {String} filename
     * @param {String} source
     * @param {Object} sourceTree
     * @private
     */
Function (anonymous_39)
✓ Was called    _createJsFileInstance: function(filename, source, sourceTree) {···
        return new JsFile(filename, source, sourceTree, {
            es3: this._configuration.isES3Enabled(),
            es6: this._configuration.isESNextEnabled()
        });
    },
    _createJsFileInstance: function(filename, source, sourceTree) {
        return new JsFile(filename, source, sourceTree, {
            es3: this._configuration.isES3Enabled(),
            es6: this._configuration.isESNextEnabled()
        });
    },
    /**
     * Checks file provided with a string.
     * @param {String} source
     * @param {String} [filename='input']
     * @returns {{output: String, errors: Errors}}
     */
Function (anonymous_40)
✓ Was called    fixString: function(source, filename) {···
        if (this._maxErrorsEnabled()) {
            throw new Error('Cannot autofix when `maxError` option is enabled');
        }

        filename = filename || 'input';

        var sourceTree;
        var parseError;

        try {
            sourceTree = JsFile.parse(source, this._esprima, this._configuration.getEsprimaOptions());
        } catch (e) {
            parseError = e;
        }

        if (parseError) {
            var parseErrors = new Errors(this._createJsFileInstance(filename, source, sourceTree), this._verbose);
            this._addParseError(parseErrors, parseError);
            return {output: source, errors: parseErrors};
        } else {
            var attempt = 0;
            var errors;
            var file;

            do {
                file = this._createJsFileInstance(filename, source, sourceTree);
                errors = new Errors(file, this._verbose);

                // Changes to current sources are made in rules through assertions.
                this._checkJsFile(file, errors);

                var hasFixes = errors.getErrorList().some(function(err) {
                    return err.fixed;
                });

                if (!hasFixes) {
                    break;
                }

                source = file.render();
                sourceTree = JsFile.parse(source, this._esprima, this._configuration.getEsprimaOptions());

                attempt++;
            } while (attempt < MAX_FIX_ATTEMPTS);

            return {output: source, errors: errors};
        }
    },
    fixString: function(source, filename) {
Branch IfStatement
✗ Positive was not executed (if)        if (this._maxErrorsEnabled()) {···
            throw new Error('Cannot autofix when `maxError` option is enabled');
        }
✓ Negative was executed (else)        }···

        filename = filename || 'input';
        if (this._maxErrorsEnabled()) {
            throw new Error('Cannot autofix when `maxError` option is enabled');
        }
Branch LogicalExpression
✓ Was returned        filename = filename || 'input';
✓ Was returned        filename = filename || 'input';
        filename = filename || 'input';
        var sourceTree;
        var parseError;
        try {
            sourceTree = JsFile.parse(source, this._esprima, this._configuration.getEsprimaOptions());
        } catch (e) {
            parseError = e;
        }
Branch IfStatement
✓ Positive was executed (if)        if (parseError) {···
            var parseErrors = new Errors(this._createJsFileInstance(filename, source, sourceTree), this._verbose);
            this._addParseError(parseErrors, parseError);
            return {output: source, errors: parseErrors};
        } else {
✓ Negative was executed (else)        } else {···
            var attempt = 0;
            var errors;
            var file;

            do {
                file = this._createJsFileInstance(filename, source, sourceTree);
                errors = new Errors(file, this._verbose);

                // Changes to current sources are made in rules through assertions.
                this._checkJsFile(file, errors);

                var hasFixes = errors.getErrorList().some(function(err) {
                    return err.fixed;
                });

                if (!hasFixes) {
                    break;
                }

                source = file.render();
                sourceTree = JsFile.parse(source, this._esprima, this._configuration.getEsprimaOptions());

                attempt++;
            } while (attempt < MAX_FIX_ATTEMPTS);

            return {output: source, errors: errors};
        }
        if (parseError) {
            var parseErrors = new Errors(this._createJsFileInstance(filename, source, sourceTree), this._verbose);
            this._addParseError(parseErrors, parseError);
            return {output: source, errors: parseErrors};
        } else {
            var attempt = 0;
            var errors;
            var file;
            do {
                file = this._createJsFileInstance(filename, source, sourceTree);
                errors = new Errors(file, this._verbose);
                // Changes to current sources are made in rules through assertions.
                this._checkJsFile(file, errors);
Function (anonymous_41)
✓ Was called                var hasFixes = errors.getErrorList().some(function(err) {···
                    return err.fixed;
                });
                var hasFixes = errors.getErrorList().some(function(err) {
                    return err.fixed;
                });
Branch IfStatement
✓ Positive was executed (if)                if (!hasFixes) {···
                    break;
                }
✓ Negative was executed (else)                }···

                source = file.render();
                if (!hasFixes) {
                    break;
                }
                source = file.render();
                sourceTree = JsFile.parse(source, this._esprima, this._configuration.getEsprimaOptions());
                attempt++;
            } while (attempt < MAX_FIX_ATTEMPTS);
            return {output: source, errors: errors};
        }
    },
    /**
     * Returns `true` if max erros limit is enabled.
     *
     * @returns {Boolean}
     */
Function (anonymous_42)
✓ Was called    _maxErrorsEnabled: function() {···
        return this._maxErrors !== null && !isNaN(this._maxErrors);
    },
    _maxErrorsEnabled: function() {
Branch LogicalExpression
✓ Was returned        return this._maxErrors !== null && !isNaN(this._maxErrors);
✓ Was returned        return this._maxErrors !== null && !isNaN(this._maxErrors);
        return this._maxErrors !== null && !isNaN(this._maxErrors);
    },
    /**
     * Returns `true` if error count exceeded `maxErrors` option value.
     *
     * @returns {Boolean}
     */
Function (anonymous_43)
✗ Was not called    maxErrorsExceeded: function() {···
        return this._maxErrorsExceeded;
    },
    maxErrorsExceeded: function() {
        return this._maxErrorsExceeded;
    },
    /**
     * Returns new configuration instance.
     *
     * @protected
     * @returns {Configuration}
     */
Function (anonymous_44)
✓ Was called    _createConfiguration: function() {···
        return new Configuration();
    },
    _createConfiguration: function() {
        return new Configuration();
    },
    /**
     * Returns current configuration instance.
     *
     * @returns {Configuration}
     */
Function (anonymous_45)
✗ Was not called    getConfiguration: function() {···
        return this._configuration;
    }
    getConfiguration: function() {
        return this._configuration;
    }
};
module.exports = StringChecker;

Function (anonymous_28)
✓ Was called	var StringChecker = function(options) {··· this._configuredRules = []; this._errorsFound = 0; this._maxErrorsExceeded = false; this._configuration = this._createConfiguration(); this._configuration.registerDefaultPresets(); if (typeof options === 'boolean') { this._verbose = options; } else { options = options \|\| {}; this._verbose = options.verbose \|\| false; this._esprima = options.esprima \|\| (options.esnext ? harmonyEsprima : defaultEsprima); } };

Branch IfStatement
✗ Positive was not executed (if)	if (typeof options === 'boolean') {··· this._verbose = options; } else {
✓ Negative was executed (else)	} else {··· options = options \|\| {}; this._verbose = options.verbose \|\| false; this._esprima = options.esprima \|\| (options.esnext ? harmonyEsprima : defaultEsprima); }

Branch LogicalExpression
✓ Was returned	options = options \|\| {};
✓ Was returned	options = options \|\| {};

Branch LogicalExpression
✓ Was returned	this._verbose = options.verbose \|\| false;
✓ Was returned	this._verbose = options.verbose \|\| false;

Branch LogicalExpression
✓ Was returned	this._esprima = options.esprima \|\| (options.esnext ? harmonyEsprima : defaultEsprima);
✓ Was returned	this._esprima = options.esprima \|\| (options.esnext ? harmonyEsprima : defaultEsprima);

Branch ConditionalExpression
✓ Positive was returned (? ...)	this._esprima = options.esprima \|\| (options.esnext ? harmonyEsprima : defaultEsprima);
✓ Negative was returned (: ...)	this._esprima = options.esprima \|\| (options.esnext ? harmonyEsprima : defaultEsprima);

Function (anonymous_29)
✓ Was called	registerRule: function(rule) {··· this._configuration.registerRule(rule); },

Function (anonymous_30)
✓ Was called	registerDefaultRules: function() {··· this._configuration.registerDefaultRules(); },

Function (anonymous_31)
✗ Was not called	getProcessedConfig: function() {··· return this._configuration.getProcessedConfig(); },

Function (anonymous_32)
✓ Was called	configure: function(config) {··· this._configuration.load(config); if (this._configuration.hasCustomEsprima()) { this._esprima = this._configuration.getCustomEsprima(); } else if (this._configuration.isESNextEnabled()) { this._esprima = harmonyEsprima; } if (this._verbose === false) { this._verbose = this._configuration.getVerbose(); } this._configuredRules = this._configuration.getConfiguredRules(); this._maxErrors = this._configuration.getMaxErrors(); },

Branch IfStatement
✗ Positive was not executed (if)	if (this._configuration.hasCustomEsprima()) {··· this._esprima = this._configuration.getCustomEsprima(); } else if (this._configuration.isESNextEnabled()) {
✓ Negative was executed (else)	} else if (this._configuration.isESNextEnabled()) {··· this._esprima = harmonyEsprima; }

Branch IfStatement
✓ Positive was executed (if)	} else if (this._configuration.isESNextEnabled()) {··· this._esprima = harmonyEsprima; }
✓ Negative was executed (else)	}··· if (this._verbose === false) {

Branch IfStatement
✓ Positive was executed (if)	if (this._verbose === false) {··· this._verbose = this._configuration.getVerbose(); }
✓ Negative was executed (else)	}··· this._configuredRules = this._configuration.getConfiguredRules();

Function (anonymous_33)
✓ Was called	checkString: function(source, filename) {··· filename = filename \|\| 'input'; var sourceTree; var parseError; try { sourceTree = JsFile.parse(source, this._esprima, this._configuration.getEsprimaOptions()); } catch (e) { parseError = e; } var file = this._createJsFileInstance(filename, source, sourceTree); var errors = new Errors(file, this._verbose); if (this._maxErrorsExceeded) { return errors; } if (parseError) { this._addParseError(errors, parseError); return errors; } this._checkJsFile(file, errors); return errors; },

errors.js
var assert = require('assert');
var chalk = require('chalk');
var TokenAssert = require('./token-assert');
/**
 * Set of errors for specified file.
 *
 * @name Errors
 * @param {JsFile} file
 * @param {Boolean} verbose
 */
Function (anonymous_46)
✓ Was calledvar Errors = function(file, verbose) {···
    this._errorList = [];
    this._file = file;
    this._currentRule = '';
    this._verbose = verbose || false;

    /**
     * @type {TokenAssert}
     * @public
     */
    this.assert = new TokenAssert(file);
    this.assert.on('error', this._addError.bind(this));
};
var Errors = function(file, verbose) {
    this._errorList = [];
    this._file = file;
    this._currentRule = '';
Branch LogicalExpression
✓ Was returned    this._verbose = verbose || false;
✓ Was returned    this._verbose = verbose || false;
    this._verbose = verbose || false;
    /**
     * @type {TokenAssert}
     * @public
     */
    this.assert = new TokenAssert(file);
    this.assert.on('error', this._addError.bind(this));
};
Errors.prototype = {
    /**
     * Adds style error to the list
     *
     * @param {String} message
     * @param {Number|Object} line
     * @param {Number} [column] optional if line is an object
     */
Function (anonymous_47)
✓ Was called    add: function(message, line, column) {···
        if (typeof line === 'object') {
            column = line.column;
            line = line.line;
        }

        // line and column numbers should be explicit
        assert(typeof line === 'number' && line > 0,
            'Unable to add an error, `line` should be a number greater than 0 but ' + line + ' given');
        assert(typeof column === 'number' && column >= 0,
            'Unable to add an error, `column` should be a positive number but ' + column + ' given');

        this._addError({
            message: message,
            line: line,
            column: column
        });
    },
    add: function(message, line, column) {
Branch IfStatement
✓ Positive was executed (if)        if (typeof line === 'object') {···
            column = line.column;
            line = line.line;
        }
✓ Negative was executed (else)        }···

        // line and column numbers should be explicit
        if (typeof line === 'object') {
            column = line.column;
            line = line.line;
        }
        // line and column numbers should be explicit
Branch LogicalExpression
✓ Was returned        assert(typeof line === 'number' && line > 0,
✓ Was returned        assert(typeof line === 'number' && line > 0,
        assert(typeof line === 'number' && line > 0,
            'Unable to add an error, `line` should be a number greater than 0 but ' + line + ' given');
Branch LogicalExpression
✓ Was returned        assert(typeof column === 'number' && column >= 0,
✓ Was returned        assert(typeof column === 'number' && column >= 0,
        assert(typeof column === 'number' && column >= 0,
            'Unable to add an error, `column` should be a positive number but ' + column + ' given');
        this._addError({
            message: message,
            line: line,
            column: column
        });
    },
    /**
     * Adds error to error list.
     *
     * @param {Object} errorInfo
     * @private
     */
Function (anonymous_48)
✓ Was called    _addError: function(errorInfo) {···
        if (!this._file.isEnabledRule(this._currentRule, errorInfo.line)) {
            return;
        }

        this._errorList.push({
            filename: this._file.getFilename(),
            rule: this._currentRule,
            message: this._prepareMessage(errorInfo),
            line: errorInfo.line,
            column: errorInfo.column,
            fixed: errorInfo.fixed
        });
    },
    _addError: function(errorInfo) {
Branch IfStatement
✓ Positive was executed (if)        if (!this._file.isEnabledRule(this._currentRule, errorInfo.line)) {···
            return;
        }
✓ Negative was executed (else)        }···

        this._errorList.push({
        if (!this._file.isEnabledRule(this._currentRule, errorInfo.line)) {
            return;
        }
        this._errorList.push({
            filename: this._file.getFilename(),
            rule: this._currentRule,
            message: this._prepareMessage(errorInfo),
            line: errorInfo.line,
            column: errorInfo.column,
            fixed: errorInfo.fixed
        });
    },
    /**
     * Prepare error message.
     *
     * @param {Object} errorInfo
     * @private
     */
Function (anonymous_49)
✓ Was called    _prepareMessage: function(errorInfo) {···
        if (this._verbose && this._currentRule) {
            return this._currentRule + ': ' + errorInfo.message;
        }

        return errorInfo.message;
    },
    _prepareMessage: function(errorInfo) {
Branch IfStatement
✓ Positive was executed (if)        if (this._verbose && this._currentRule) {···
            return this._currentRule + ': ' + errorInfo.message;
        }
✓ Negative was executed (else)        }···

        return errorInfo.message;
Branch LogicalExpression
✓ Was returned        if (this._verbose && this._currentRule) {
✓ Was returned        if (this._verbose && this._currentRule) {
        if (this._verbose && this._currentRule) {
            return this._currentRule + ': ' + errorInfo.message;
        }
        return errorInfo.message;
    },
    /**
     * Returns style error list.
     *
     * @returns {Object[]}
     */
Function (anonymous_50)
✓ Was called    getErrorList: function() {···
        return this._errorList;
    },
    getErrorList: function() {
        return this._errorList;
    },
    /**
     * Returns filename of file this error list is for.
     *
     * @returns {String}
     */
Function (anonymous_51)
✓ Was called    getFilename: function() {···
        return this._file.getFilename();
    },
    getFilename: function() {
        return this._file.getFilename();
    },
    /**
     * Returns true if no errors are added.
     *
     * @returns {Boolean}
     */
Function (anonymous_52)
✓ Was called    isEmpty: function() {···
        return this._errorList.length === 0;
    },
    isEmpty: function() {
        return this._errorList.length === 0;
    },
    /**
     * Returns amount of errors added by the rules.
     *
     * @returns {Number}
     */
Function (anonymous_53)
✓ Was called    getErrorCount: function() {···
        return this._errorList.length;
    },
    getErrorCount: function() {
        return this._errorList.length;
    },
    /**
     * Strips error list to the specified length.
     *
     * @param {Number} length
     */
Function (anonymous_54)
✓ Was called    stripErrorList: function(length) {···
        this._errorList.splice(length);
    },
    stripErrorList: function(length) {
        this._errorList.splice(length);
    },
    /**
     * Filters out errors based on the supplied filter function
     *
     * @param {Function} filter
     */
Function (anonymous_55)
✓ Was called    filter: function(filter) {···
        this._errorList = this._errorList.filter(filter);
    },
    filter: function(filter) {
        this._errorList = this._errorList.filter(filter);
    },
    /**
     * Formats error for further output.
     *
     * @param {Object} error
     * @param {Boolean} [colorize = false]
     * @returns {String}
     */
Function (anonymous_56)
✓ Was called    explainError: function(error, colorize) {···
        var lineNumber = error.line - 1;
        var lines = this._file.getLines();
        var result = [
            renderLine(lineNumber, lines[lineNumber], colorize),
            renderPointer(error.column, colorize)
        ];
        var i = lineNumber - 1;
        var linesAround = 2;
        while (i >= 0 && i >= (lineNumber - linesAround)) {
            result.unshift(renderLine(i, lines[i], colorize));
            i--;
        }
        i = lineNumber + 1;
        while (i < lines.length && i <= (lineNumber + linesAround)) {
            result.push(renderLine(i, lines[i], colorize));
            i++;
        }
        result.unshift(formatErrorMessage(error.message, this.getFilename(), colorize));
        return result.join('\n');
    },
    explainError: function(error, colorize) {
        var lineNumber = error.line - 1;
        var lines = this._file.getLines();
        var result = [
            renderLine(lineNumber, lines[lineNumber], colorize),
            renderPointer(error.column, colorize)
        ];
        var i = lineNumber - 1;
        var linesAround = 2;
Branch LogicalExpression
✓ Was returned        while (i >= 0 && i >= (lineNumber - linesAround)) {
✓ Was returned        while (i >= 0 && i >= (lineNumber - linesAround)) {
        while (i >= 0 && i >= (lineNumber - linesAround)) {
            result.unshift(renderLine(i, lines[i], colorize));
            i--;
        }
        i = lineNumber + 1;
Branch LogicalExpression
✓ Was returned        while (i < lines.length && i <= (lineNumber + linesAround)) {
✓ Was returned        while (i < lines.length && i <= (lineNumber + linesAround)) {
        while (i < lines.length && i <= (lineNumber + linesAround)) {
            result.push(renderLine(i, lines[i], colorize));
            i++;
        }
        result.unshift(formatErrorMessage(error.message, this.getFilename(), colorize));
        return result.join('\n');
    },
    /**
     * Sets the current rule so that errors are aware
     * of which rule triggered them.
     *
     * @param {String} rule
     */
Function (anonymous_57)
✓ Was called    setCurrentRule: function(rule) {···
        this._currentRule = rule;
    }
    setCurrentRule: function(rule) {
        this._currentRule = rule;
    }
};
/**
 * Formats error message header.
 *
 * @param {String} message
 * @param {String} filename
 * @param {Boolean} colorize
 * @returns {String}
 */
Function formatErrorMessage
✓ Was calledfunction formatErrorMessage(message, filename, colorize) {···
    return (colorize ? chalk.bold(message) : message) +
        ' at ' +
        (colorize ? chalk.green(filename) : filename) + ' :';
}
function formatErrorMessage(message, filename, colorize) {
Branch ConditionalExpression
✓ Positive was returned (? ...)    return (colorize ? chalk.bold(message) : message) +
✓ Negative was returned (: ...)    return (colorize ? chalk.bold(message) : message) +
    return (colorize ? chalk.bold(message) : message) +
        ' at ' +
Branch ConditionalExpression
✓ Positive was returned (? ...)        (colorize ? chalk.green(filename) : filename) + ' :';
✓ Negative was returned (: ...)        (colorize ? chalk.green(filename) : filename) + ' :';
        (colorize ? chalk.green(filename) : filename) + ' :';
}
/**
 * Simple util for prepending spaces to the string until it fits specified size.
 *
 * @param {String} s
 * @param {Number} len
 * @returns {String}
 */
Function prependSpaces
✓ Was calledfunction prependSpaces(s, len) {···
    while (s.length < len) {
        s = ' ' + s;
    }
    return s;
}
function prependSpaces(s, len) {
    while (s.length < len) {
        s = ' ' + s;
    }
    return s;
}
/**
 * Renders single line of code in style error formatted output.
 *
 * @param {Number} n line number
 * @param {String} line
 * @param {Boolean} [colorize = false]
 * @returns {String}
 */
Function renderLine
✓ Was calledfunction renderLine(n, line, colorize) {···
    // Convert tabs to spaces, so errors in code lines with tabs as indention symbol
    // could be correctly rendered, plus it will provide less verbose output
    line = line.replace(/\t/g, ' ');

    // "n + 1" to print lines in human way (counted from 1)
    var lineNumber = prependSpaces((n + 1).toString(), 5) + ' |';
    return ' ' + (colorize ? chalk.grey(lineNumber) : lineNumber) + line;
}
function renderLine(n, line, colorize) {
    // Convert tabs to spaces, so errors in code lines with tabs as indention symbol
    // could be correctly rendered, plus it will provide less verbose output
    line = line.replace(/\t/g, ' ');
    // "n + 1" to print lines in human way (counted from 1)
    var lineNumber = prependSpaces((n + 1).toString(), 5) + ' |';
Branch ConditionalExpression
✓ Positive was returned (? ...)    return ' ' + (colorize ? chalk.grey(lineNumber) : lineNumber) + line;
✓ Negative was returned (: ...)    return ' ' + (colorize ? chalk.grey(lineNumber) : lineNumber) + line;
    return ' ' + (colorize ? chalk.grey(lineNumber) : lineNumber) + line;
}
/**
 * Renders pointer:
 * ---------------^
 *
 * @param {Number} column
 * @param {Boolean} [colorize = false]
 * @returns {String}
 */
Function renderPointer
✓ Was calledfunction renderPointer(column, colorize) {···
    var res = (new Array(column + 9)).join('-') + '^';
    return colorize ? chalk.grey(res) : res;
}
function renderPointer(column, colorize) {
    var res = (new Array(column + 9)).join('-') + '^';
Branch ConditionalExpression
✓ Positive was returned (? ...)    return colorize ? chalk.grey(res) : res;
✓ Negative was returned (: ...)    return colorize ? chalk.grey(res) : res;
    return colorize ? chalk.grey(res) : res;
}
module.exports = Errors;

token-assert.js
var utils = require('util');
var EventEmitter = require('events').EventEmitter;
/**
 * Token assertions class.
 *
 * @name {TokenAssert}
 * @param {JsFile} file
 */
Function TokenAssert
✓ Was calledfunction TokenAssert(file) {···
    EventEmitter.call(this);

    this._file = file;
}
function TokenAssert(file) {
    EventEmitter.call(this);
    this._file = file;
}
utils.inherits(TokenAssert, EventEmitter);
/**
 * Requires to have whitespace between specified tokens. Ignores newlines.
 *
 * @param {Object} options.token
 * @param {Object} options.nextToken
 * @param {String} [options.message]
 * @param {Number} [options.spaces] Amount of spaces between tokens.
 */
Function (anonymous_63)
✓ Was calledTokenAssert.prototype.whitespaceBetween = function(options) {···
    options.atLeast = 1;
    this.spacesBetween(options);
};
TokenAssert.prototype.whitespaceBetween = function(options) {
    options.atLeast = 1;
    this.spacesBetween(options);
};
/**
 * Requires to have no whitespace between specified tokens.
 *
 * @param {Object} options.token
 * @param {Object} options.nextToken
 * @param {String} [options.message]
 * @param {Boolean} [options.disallowNewLine=false]
 */
Function (anonymous_64)
✓ Was calledTokenAssert.prototype.noWhitespaceBetween = function(options) {···
    options.exactly = 0;
    this.spacesBetween(options);
};
TokenAssert.prototype.noWhitespaceBetween = function(options) {
    options.exactly = 0;
    this.spacesBetween(options);
};
/**
 * Requires to have the whitespace between specified tokens with the provided options.
 *
 * @param {Object} options.token
 * @param {Object} options.nextToken
 * @param {String} [options.message]
 * @param {Object} [options.atLeast] At least how many spaces the tokens are apart
 * @param {Object} [options.atMost] At most how many spaces the tokens are apart
 * @param {Object} [options.exactly] Exactly how many spaces the tokens are apart
 * @param {Boolean} [options.disallowNewLine=false]
 */
Function (anonymous_65)
✓ Was calledTokenAssert.prototype.spacesBetween = function(options) {···
    var token = options.token;
    var nextToken = options.nextToken;
    var atLeast = options.atLeast;
    var atMost = options.atMost;
    var exactly = options.exactly;

    if (!token || !nextToken) {
        return;
    }

    this._validateOptions(options);

    if (!options.disallowNewLine && token.loc.end.line !== nextToken.loc.start.line) {
        return;
    }

    // Only attempt to remove or add lines if there are no comments between the two nodes
    // as this prevents accidentally moving a valid token onto a line comment ed line
    var fixed = this._file.getNextToken(options.token, {includeComments: true}) === nextToken;

    var emitError = function(countPrefix, spaceCount) {
        if (fixed) {
            nextToken.whitespaceBefore = new Array(spaceCount + 1).join(' ');
        }

        var msgPostfix = token.value + ' and ' + nextToken.value;

        if (!options.message) {
            if (exactly === 0) {
                // support noWhitespaceBetween
                options.message = 'Unexpected whitespace between ' + msgPostfix;
            } else if (exactly !== undefined) {
                // support whitespaceBetween (spaces option)
                options.message = spaceCount + ' spaces required between ' + msgPostfix;
            } else if (atLeast === 1 && atMost === undefined) {
                // support whitespaceBetween (no spaces option)
                options.message = 'Missing space between ' + msgPostfix;
            } else {
                options.message = countPrefix + ' ' + spaceCount + ' spaces required between ' + msgPostfix;
            }
        }

        this.emit('error', {
            message: options.message,
            line: token.loc.end.line,
            column: token.loc.end.column,
            fixed: fixed
        });
    }.bind(this);

    var spacesBetween = Math.abs(nextToken.range[0] - token.range[1]);
    if (atLeast !== undefined && spacesBetween < atLeast) {
        emitError('at least', atLeast);
    } else if (atMost !== undefined && spacesBetween > atMost) {
        emitError('at most', atMost);
    } else if (exactly !== undefined && spacesBetween !== exactly) {
        emitError('exactly', exactly);
    }
};
TokenAssert.prototype.spacesBetween = function(options) {
    var token = options.token;
    var nextToken = options.nextToken;
    var atLeast = options.atLeast;
    var atMost = options.atMost;
    var exactly = options.exactly;
Branch IfStatement
✓ Positive was executed (if)    if (!token || !nextToken) {···
        return;
    }
✓ Negative was executed (else)    }···

    this._validateOptions(options);
Branch LogicalExpression
✓ Was returned    if (!token || !nextToken) {
✓ Was returned    if (!token || !nextToken) {
    if (!token || !nextToken) {
        return;
    }
    this._validateOptions(options);
Branch IfStatement
✓ Positive was executed (if)    if (!options.disallowNewLine && token.loc.end.line !== nextToken.loc.start.line) {···
        return;
    }
✓ Negative was executed (else)    }···

    // Only attempt to remove or add lines if there are no comments between the two nodes
Branch LogicalExpression
✓ Was returned    if (!options.disallowNewLine && token.loc.end.line !== nextToken.loc.start.line) {
✓ Was returned    if (!options.disallowNewLine && token.loc.end.line !== nextToken.loc.start.line) {
    if (!options.disallowNewLine && token.loc.end.line !== nextToken.loc.start.line) {
        return;
    }
    // Only attempt to remove or add lines if there are no comments between the two nodes
    // as this prevents accidentally moving a valid token onto a line comment ed line
    var fixed = this._file.getNextToken(options.token, {includeComments: true}) === nextToken;
Function (anonymous_66)
✓ Was called    var emitError = function(countPrefix, spaceCount) {···
        if (fixed) {
            nextToken.whitespaceBefore = new Array(spaceCount + 1).join(' ');
        }

        var msgPostfix = token.value + ' and ' + nextToken.value;

        if (!options.message) {
            if (exactly === 0) {
                // support noWhitespaceBetween
                options.message = 'Unexpected whitespace between ' + msgPostfix;
            } else if (exactly !== undefined) {
                // support whitespaceBetween (spaces option)
                options.message = spaceCount + ' spaces required between ' + msgPostfix;
            } else if (atLeast === 1 && atMost === undefined) {
                // support whitespaceBetween (no spaces option)
                options.message = 'Missing space between ' + msgPostfix;
            } else {
                options.message = countPrefix + ' ' + spaceCount + ' spaces required between ' + msgPostfix;
            }
        }

        this.emit('error', {
            message: options.message,
            line: token.loc.end.line,
            column: token.loc.end.column,
            fixed: fixed
        });
    }.bind(this);
    var emitError = function(countPrefix, spaceCount) {
Branch IfStatement
✓ Positive was executed (if)        if (fixed) {···
            nextToken.whitespaceBefore = new Array(spaceCount + 1).join(' ');
        }
✓ Negative was executed (else)        }···

        var msgPostfix = token.value + ' and ' + nextToken.value;
        if (fixed) {
            nextToken.whitespaceBefore = new Array(spaceCount + 1).join(' ');
        }
        var msgPostfix = token.value + ' and ' + nextToken.value;
Branch IfStatement
✓ Positive was executed (if)        if (!options.message) {···
            if (exactly === 0) {
                // support noWhitespaceBetween
                options.message = 'Unexpected whitespace between ' + msgPostfix;
            } else if (exactly !== undefined) {
                // support whitespaceBetween (spaces option)
                options.message = spaceCount + ' spaces required between ' + msgPostfix;
            } else if (atLeast === 1 && atMost === undefined) {
                // support whitespaceBetween (no spaces option)
                options.message = 'Missing space between ' + msgPostfix;
            } else {
                options.message = countPrefix + ' ' + spaceCount + ' spaces required between ' + msgPostfix;
            }
        }
✓ Negative was executed (else)        }···

        this.emit('error', {
        if (!options.message) {
Branch IfStatement
✓ Positive was executed (if)            if (exactly === 0) {···
                // support noWhitespaceBetween
                options.message = 'Unexpected whitespace between ' + msgPostfix;
            } else if (exactly !== undefined) {
✓ Negative was executed (else)            } else if (exactly !== undefined) {···
                // support whitespaceBetween (spaces option)
                options.message = spaceCount + ' spaces required between ' + msgPostfix;
            } else if (atLeast === 1 && atMost === undefined) {
                // support whitespaceBetween (no spaces option)
                options.message = 'Missing space between ' + msgPostfix;
            } else {
                options.message = countPrefix + ' ' + spaceCount + ' spaces required between ' + msgPostfix;
            }
            if (exactly === 0) {
                // support noWhitespaceBetween
                options.message = 'Unexpected whitespace between ' + msgPostfix;
Branch IfStatement
✓ Positive was executed (if)            } else if (exactly !== undefined) {···
                // support whitespaceBetween (spaces option)
                options.message = spaceCount + ' spaces required between ' + msgPostfix;
            } else if (atLeast === 1 && atMost === undefined) {
✓ Negative was executed (else)            } else if (atLeast === 1 && atMost === undefined) {···
                // support whitespaceBetween (no spaces option)
                options.message = 'Missing space between ' + msgPostfix;
            } else {
                options.message = countPrefix + ' ' + spaceCount + ' spaces required between ' + msgPostfix;
            }
            } else if (exactly !== undefined) {
                // support whitespaceBetween (spaces option)
                options.message = spaceCount + ' spaces required between ' + msgPostfix;
Branch IfStatement
✓ Positive was executed (if)            } else if (atLeast === 1 && atMost === undefined) {···
                // support whitespaceBetween (no spaces option)
                options.message = 'Missing space between ' + msgPostfix;
            } else {
✓ Negative was executed (else)            } else {···
                options.message = countPrefix + ' ' + spaceCount + ' spaces required between ' + msgPostfix;
            }
Branch LogicalExpression
✓ Was returned            } else if (atLeast === 1 && atMost === undefined) {
✓ Was returned            } else if (atLeast === 1 && atMost === undefined) {
            } else if (atLeast === 1 && atMost === undefined) {
                // support whitespaceBetween (no spaces option)
                options.message = 'Missing space between ' + msgPostfix;
            } else {
                options.message = countPrefix + ' ' + spaceCount + ' spaces required between ' + msgPostfix;
            }
        }
        this.emit('error', {
            message: options.message,
            line: token.loc.end.line,
            column: token.loc.end.column,
            fixed: fixed
        });
    }.bind(this);
    var spacesBetween = Math.abs(nextToken.range[0] - token.range[1]);
Branch IfStatement
✓ Positive was executed (if)    if (atLeast !== undefined && spacesBetween < atLeast) {···
        emitError('at least', atLeast);
    } else if (atMost !== undefined && spacesBetween > atMost) {
✓ Negative was executed (else)    } else if (atMost !== undefined && spacesBetween > atMost) {···
        emitError('at most', atMost);
    } else if (exactly !== undefined && spacesBetween !== exactly) {
        emitError('exactly', exactly);
    }
Branch LogicalExpression
✓ Was returned    if (atLeast !== undefined && spacesBetween < atLeast) {
✓ Was returned    if (atLeast !== undefined && spacesBetween < atLeast) {
    if (atLeast !== undefined && spacesBetween < atLeast) {
        emitError('at least', atLeast);
Branch IfStatement
✓ Positive was executed (if)    } else if (atMost !== undefined && spacesBetween > atMost) {···
        emitError('at most', atMost);
    } else if (exactly !== undefined && spacesBetween !== exactly) {
✓ Negative was executed (else)    } else if (exactly !== undefined && spacesBetween !== exactly) {···
        emitError('exactly', exactly);
    }
Branch LogicalExpression
✓ Was returned    } else if (atMost !== undefined && spacesBetween > atMost) {
✓ Was returned    } else if (atMost !== undefined && spacesBetween > atMost) {
    } else if (atMost !== undefined && spacesBetween > atMost) {
        emitError('at most', atMost);
Branch IfStatement
✓ Positive was executed (if)    } else if (exactly !== undefined && spacesBetween !== exactly) {···
        emitError('exactly', exactly);
    }
✓ Negative was executed (else)    }···
};
Branch LogicalExpression
✓ Was returned    } else if (exactly !== undefined && spacesBetween !== exactly) {
✓ Was returned    } else if (exactly !== undefined && spacesBetween !== exactly) {
    } else if (exactly !== undefined && spacesBetween !== exactly) {
        emitError('exactly', exactly);
    }
};
/**
 * Requires the specified line to have the expected indentation.
 *
 * @param {Number} options.lineNumber
 * @param {Number} options.actual
 * @param {Number} options.expected
 * @param {String} options.indentChar
 * @param {Boolean} [options.silent] if true, will suppress error emission but still fix whitespace
 */
Function (anonymous_67)
✓ Was calledTokenAssert.prototype.indentation = function(options) {···
    var lineNumber = options.lineNumber;
    var actual = options.actual;
    var expected = options.expected;
    var indentChar = options.indentChar;

    if (actual === expected) {
        return;
    }

    if (!options.silent) {
        this.emit('error', {
            message: 'Expected indentation of ' + expected + ' characters',
            line: lineNumber,
            column: expected,
            fixed: true
        });
    }

    var token = this._file.getFirstTokenOnLine(lineNumber, {includeComments: true});
    var newWhitespace = (new Array(expected + 1)).join(indentChar);

    if (!token) {
        this._setEmptyLineIndentation(lineNumber, newWhitespace);
        return;
    }

    this._updateWhitespaceByLine(token, function(lines) {
        lines[lines.length - 1] = newWhitespace;

        return lines;
    });

    if (token.isComment) {
        this._updateCommentWhitespace(token, indentChar, actual, expected);
    }
};
TokenAssert.prototype.indentation = function(options) {
    var lineNumber = options.lineNumber;
    var actual = options.actual;
    var expected = options.expected;
    var indentChar = options.indentChar;
Branch IfStatement
✓ Positive was executed (if)    if (actual === expected) {···
        return;
    }
✓ Negative was executed (else)    }···

    if (!options.silent) {
    if (actual === expected) {
        return;
    }
Branch IfStatement
✓ Positive was executed (if)    if (!options.silent) {···
        this.emit('error', {
            message: 'Expected indentation of ' + expected + ' characters',
            line: lineNumber,
            column: expected,
            fixed: true
        });
    }
✓ Negative was executed (else)    }···

    var token = this._file.getFirstTokenOnLine(lineNumber, {includeComments: true});
    if (!options.silent) {
        this.emit('error', {
            message: 'Expected indentation of ' + expected + ' characters',
            line: lineNumber,
            column: expected,
            fixed: true
        });
    }
    var token = this._file.getFirstTokenOnLine(lineNumber, {includeComments: true});
    var newWhitespace = (new Array(expected + 1)).join(indentChar);
Branch IfStatement
✓ Positive was executed (if)    if (!token) {···
        this._setEmptyLineIndentation(lineNumber, newWhitespace);
        return;
    }
✓ Negative was executed (else)    }···

    this._updateWhitespaceByLine(token, function(lines) {
    if (!token) {
        this._setEmptyLineIndentation(lineNumber, newWhitespace);
        return;
    }
Function (anonymous_68)
✓ Was called    this._updateWhitespaceByLine(token, function(lines) {···
        lines[lines.length - 1] = newWhitespace;

        return lines;
    });
    this._updateWhitespaceByLine(token, function(lines) {
        lines[lines.length - 1] = newWhitespace;
        return lines;
    });
Branch IfStatement
✓ Positive was executed (if)    if (token.isComment) {···
        this._updateCommentWhitespace(token, indentChar, actual, expected);
    }
✓ Negative was executed (else)    }···
};
    if (token.isComment) {
        this._updateCommentWhitespace(token, indentChar, actual, expected);
    }
};
/**
 * Updates the whitespace of a line by passing split lines to a callback function
 * for editing.
 *
 * @param  {Number} lineNumber
 * @param  {Function} callback
 */
Function (anonymous_69)
✓ Was calledTokenAssert.prototype._updateWhitespaceByLine = function(token, callback) {···
    var lineBreak = this._file.getLineBreakStyle();
    var lines = token.whitespaceBefore.split(/\r\n|\r|\n/);

    lines = callback(lines);
    token.whitespaceBefore = lines.join(lineBreak);
};
TokenAssert.prototype._updateWhitespaceByLine = function(token, callback) {
    var lineBreak = this._file.getLineBreakStyle();
    var lines = token.whitespaceBefore.split(/\r\n|\r|\n/);
    lines = callback(lines);
    token.whitespaceBefore = lines.join(lineBreak);
};
/**
 * Updates the whitespace of a line by passing split lines to a callback function
 * for editing.
 *
 * @param  {Number} lineNumber
 * @param  {Function} callback
 */
Function (anonymous_70)
✓ Was calledTokenAssert.prototype._updateCommentWhitespace = function(token, indentChar, actual, expected) {···
    var difference = expected - actual;
    var tokenLines = token.value.split(/\r\n|\r|\n/);
    var i = 1;
    if (difference >= 0) {
        var lineWhitespace = (new Array(difference + 1)).join(indentChar);
        for (; i < tokenLines.length; i++) {
            tokenLines[i] = tokenLines[i] === '' ? '' : lineWhitespace + tokenLines[i];
        }
    } else {
        for (; i < tokenLines.length; i++) {
            tokenLines[i] = tokenLines[i].substring(-difference);
        }
    }

    token.value = tokenLines.join(this._file.getLineBreakStyle());
};
TokenAssert.prototype._updateCommentWhitespace = function(token, indentChar, actual, expected) {
    var difference = expected - actual;
    var tokenLines = token.value.split(/\r\n|\r|\n/);
    var i = 1;
Branch IfStatement
✓ Positive was executed (if)    if (difference >= 0) {···
        var lineWhitespace = (new Array(difference + 1)).join(indentChar);
        for (; i < tokenLines.length; i++) {
            tokenLines[i] = tokenLines[i] === '' ? '' : lineWhitespace + tokenLines[i];
        }
    } else {
✓ Negative was executed (else)    } else {···
        for (; i < tokenLines.length; i++) {
            tokenLines[i] = tokenLines[i].substring(-difference);
        }
    }
    if (difference >= 0) {
        var lineWhitespace = (new Array(difference + 1)).join(indentChar);
        for (; i < tokenLines.length; i++) {
Branch ConditionalExpression
✗ Positive was not returned (? ...)            tokenLines[i] = tokenLines[i] === '' ? '' : lineWhitespace + tokenLines[i];
✓ Negative was returned (: ...)            tokenLines[i] = tokenLines[i] === '' ? '' : lineWhitespace + tokenLines[i];
            tokenLines[i] = tokenLines[i] === '' ? '' : lineWhitespace + tokenLines[i];
        }
    } else {
        for (; i < tokenLines.length; i++) {
            tokenLines[i] = tokenLines[i].substring(-difference);
        }
    }
    token.value = tokenLines.join(this._file.getLineBreakStyle());
};
/**
 * Fixes the indentation of a line that has no tokens on it
 *
 * @param  {Number} lineNumber
 * @param  {String} newWhitespace
 */
Function (anonymous_71)
✓ Was calledTokenAssert.prototype._setEmptyLineIndentation = function(lineNumber, newWhitespace) {···
    var token;
    do {
        token = this._file.getFirstTokenOnLine(++lineNumber, {includeComments: true});
    } while (!token);

    this._updateWhitespaceByLine(token, function(lines) {
        if (lines[0] !== '') {
            lines[0] = newWhitespace;
        }

        for (var i = 1; i < lines.length; i++) {
            lines[i] = newWhitespace;
        }

        return lines;
    });
};
TokenAssert.prototype._setEmptyLineIndentation = function(lineNumber, newWhitespace) {
    var token;
    do {
        token = this._file.getFirstTokenOnLine(++lineNumber, {includeComments: true});
    } while (!token);
Function (anonymous_72)
✓ Was called    this._updateWhitespaceByLine(token, function(lines) {···
        if (lines[0] !== '') {
            lines[0] = newWhitespace;
        }

        for (var i = 1; i < lines.length; i++) {
            lines[i] = newWhitespace;
        }

        return lines;
    });
    this._updateWhitespaceByLine(token, function(lines) {
Branch IfStatement
✓ Positive was executed (if)        if (lines[0] !== '') {···
            lines[0] = newWhitespace;
        }
✓ Negative was executed (else)        }···

        for (var i = 1; i < lines.length; i++) {
        if (lines[0] !== '') {
            lines[0] = newWhitespace;
        }
        for (var i = 1; i < lines.length; i++) {
            lines[i] = newWhitespace;
        }
        return lines;
    });
};
/**
 * Requires tokens to be on the same line.
 *
 * @param {Object} options.token
 * @param {Object} options.nextToken
 * @param {Boolean} [options.stickToPreviousToken]
 * @param {String} [options.message]
 */
Function (anonymous_73)
✓ Was calledTokenAssert.prototype.sameLine = function(options) {···
    options.exactly = 0;

    this.linesBetween(options);
};
TokenAssert.prototype.sameLine = function(options) {
    options.exactly = 0;
    this.linesBetween(options);
};
/**
 * Requires tokens to be on different lines.
 *
 * @param {Object} options.token
 * @param {Object} options.nextToken
 * @param {Object} [options.message]
 */
Function (anonymous_74)
✓ Was calledTokenAssert.prototype.differentLine = function(options) {···
    options.atLeast = 1;

    this.linesBetween(options);
};
TokenAssert.prototype.differentLine = function(options) {
    options.atLeast = 1;
    this.linesBetween(options);
};
/**
 * Requires tokens to have a certain amount of lines between them.
 * Set at least one of atLeast or atMost OR set exactly.
 *
 * @param {Object} options.token
 * @param {Object} options.nextToken
 * @param {Object} [options.message]
 * @param {Object} [options.atLeast] At least how many lines the tokens are apart
 * @param {Object} [options.atMost] At most how many lines the tokens are apart
 * @param {Object} [options.exactly] Exactly how many lines the tokens are apart
 * @param {Boolean} [options.stickToPreviousToken] When auto-fixing stick the
 *     nextToken onto the previous token.
 */
Function (anonymous_75)
✓ Was calledTokenAssert.prototype.linesBetween = function(options) {···
    var token = options.token;
    var nextToken = options.nextToken;
    var atLeast = options.atLeast;
    var atMost = options.atMost;
    var exactly = options.exactly;

    if (!token || !nextToken) {
        return;
    }

    this._validateOptions(options);

    // Only attempt to remove or add lines if there are no comments between the two nodes
    // as this prevents accidentally moving a valid token onto a line comment ed line
    var fixed = this._file.getNextToken(options.token, {includeComments: true}) === nextToken;

    var linesBetween = Math.abs(token.loc.end.line - nextToken.loc.start.line);

    var emitError = function(countPrefix, lineCount) {
        var msgPrefix = token.value + ' and ' + nextToken.value;

        if (!options.message) {
            if (exactly === 0) {
                // support sameLine
                options.message = msgPrefix + ' should be on the same line';
            } else if (atLeast === 1 && atMost === undefined) {
                // support differentLine
                options.message = msgPrefix + ' should be on different lines';
            } else {
                // support linesBetween
                options.message = msgPrefix + ' should have ' + countPrefix + ' ' + lineCount + ' line(s) between them';
            }
        }

        if (fixed) {
            this._augmentLineCount(options, lineCount);
        }

        this.emit('error', {
            message: options.message,
            line: token.loc.end.line,
            column: token.loc.end.column,
            fixed: fixed
        });
    }.bind(this);

    if (atLeast !== undefined && linesBetween < atLeast) {
        emitError('at least', atLeast);
    } else if (atMost !== undefined && linesBetween > atMost) {
        emitError('at most', atMost);
    } else if (exactly !== undefined && linesBetween !== exactly) {
        emitError('exactly', exactly);
    }
};
TokenAssert.prototype.linesBetween = function(options) {
    var token = options.token;
    var nextToken = options.nextToken;
    var atLeast = options.atLeast;
    var atMost = options.atMost;
    var exactly = options.exactly;
Branch IfStatement
✓ Positive was executed (if)    if (!token || !nextToken) {···
        return;
    }
✓ Negative was executed (else)    }···

    this._validateOptions(options);
Branch LogicalExpression
✓ Was returned    if (!token || !nextToken) {
✓ Was returned    if (!token || !nextToken) {
    if (!token || !nextToken) {
        return;
    }
    this._validateOptions(options);
    // Only attempt to remove or add lines if there are no comments between the two nodes
    // as this prevents accidentally moving a valid token onto a line comment ed line
    var fixed = this._file.getNextToken(options.token, {includeComments: true}) === nextToken;
    var linesBetween = Math.abs(token.loc.end.line - nextToken.loc.start.line);
Function (anonymous_76)
✓ Was called    var emitError = function(countPrefix, lineCount) {···
        var msgPrefix = token.value + ' and ' + nextToken.value;

        if (!options.message) {
            if (exactly === 0) {
                // support sameLine
                options.message = msgPrefix + ' should be on the same line';
            } else if (atLeast === 1 && atMost === undefined) {
                // support differentLine
                options.message = msgPrefix + ' should be on different lines';
            } else {
                // support linesBetween
                options.message = msgPrefix + ' should have ' + countPrefix + ' ' + lineCount + ' line(s) between them';
            }
        }

        if (fixed) {
            this._augmentLineCount(options, lineCount);
        }

        this.emit('error', {
            message: options.message,
            line: token.loc.end.line,
            column: token.loc.end.column,
            fixed: fixed
        });
    }.bind(this);
    var emitError = function(countPrefix, lineCount) {
        var msgPrefix = token.value + ' and ' + nextToken.value;
Branch IfStatement
✓ Positive was executed (if)        if (!options.message) {···
            if (exactly === 0) {
                // support sameLine
                options.message = msgPrefix + ' should be on the same line';
            } else if (atLeast === 1 && atMost === undefined) {
                // support differentLine
                options.message = msgPrefix + ' should be on different lines';
            } else {
                // support linesBetween
                options.message = msgPrefix + ' should have ' + countPrefix + ' ' + lineCount + ' line(s) between them';
            }
        }
✓ Negative was executed (else)        }···

        if (fixed) {
        if (!options.message) {
Branch IfStatement
✓ Positive was executed (if)            if (exactly === 0) {···
                // support sameLine
                options.message = msgPrefix + ' should be on the same line';
            } else if (atLeast === 1 && atMost === undefined) {
✓ Negative was executed (else)            } else if (atLeast === 1 && atMost === undefined) {···
                // support differentLine
                options.message = msgPrefix + ' should be on different lines';
            } else {
                // support linesBetween
                options.message = msgPrefix + ' should have ' + countPrefix + ' ' + lineCount + ' line(s) between them';
            }
            if (exactly === 0) {
                // support sameLine
                options.message = msgPrefix + ' should be on the same line';
Branch IfStatement
✓ Positive was executed (if)            } else if (atLeast === 1 && atMost === undefined) {···
                // support differentLine
                options.message = msgPrefix + ' should be on different lines';
            } else {
✓ Negative was executed (else)            } else {···
                // support linesBetween
                options.message = msgPrefix + ' should have ' + countPrefix + ' ' + lineCount + ' line(s) between them';
            }
Branch LogicalExpression
✓ Was returned            } else if (atLeast === 1 && atMost === undefined) {
✓ Was returned            } else if (atLeast === 1 && atMost === undefined) {
            } else if (atLeast === 1 && atMost === undefined) {
                // support differentLine
                options.message = msgPrefix + ' should be on different lines';
            } else {
                // support linesBetween
                options.message = msgPrefix + ' should have ' + countPrefix + ' ' + lineCount + ' line(s) between them';
            }
        }
Branch IfStatement
✓ Positive was executed (if)        if (fixed) {···
            this._augmentLineCount(options, lineCount);
        }
✓ Negative was executed (else)        }···

        this.emit('error', {
        if (fixed) {
            this._augmentLineCount(options, lineCount);
        }
        this.emit('error', {
            message: options.message,
            line: token.loc.end.line,
            column: token.loc.end.column,
            fixed: fixed
        });
    }.bind(this);
Branch IfStatement
✓ Positive was executed (if)    if (atLeast !== undefined && linesBetween < atLeast) {···
        emitError('at least', atLeast);
    } else if (atMost !== undefined && linesBetween > atMost) {
✓ Negative was executed (else)    } else if (atMost !== undefined && linesBetween > atMost) {···
        emitError('at most', atMost);
    } else if (exactly !== undefined && linesBetween !== exactly) {
        emitError('exactly', exactly);
    }
Branch LogicalExpression
✓ Was returned    if (atLeast !== undefined && linesBetween < atLeast) {
✓ Was returned    if (atLeast !== undefined && linesBetween < atLeast) {
    if (atLeast !== undefined && linesBetween < atLeast) {
        emitError('at least', atLeast);
Branch IfStatement
✓ Positive was executed (if)    } else if (atMost !== undefined && linesBetween > atMost) {···
        emitError('at most', atMost);
    } else if (exactly !== undefined && linesBetween !== exactly) {
✓ Negative was executed (else)    } else if (exactly !== undefined && linesBetween !== exactly) {···
        emitError('exactly', exactly);
    }
Branch LogicalExpression
✓ Was returned    } else if (atMost !== undefined && linesBetween > atMost) {
✓ Was returned    } else if (atMost !== undefined && linesBetween > atMost) {
    } else if (atMost !== undefined && linesBetween > atMost) {
        emitError('at most', atMost);
Branch IfStatement
✓ Positive was executed (if)    } else if (exactly !== undefined && linesBetween !== exactly) {···
        emitError('exactly', exactly);
    }
✓ Negative was executed (else)    }···
};
Branch LogicalExpression
✓ Was returned    } else if (exactly !== undefined && linesBetween !== exactly) {
✓ Was returned    } else if (exactly !== undefined && linesBetween !== exactly) {
    } else if (exactly !== undefined && linesBetween !== exactly) {
        emitError('exactly', exactly);
    }
};
/**
 * Throws errors if atLeast, atMost, and exactly options don't mix together properly or
 * if the tokens provided are equivalent.
 *
 * @param {Object} options.token
 * @param {Object} options.nextToken
 * @param {Object} [options.atLeast] At least how many spaces the tokens are apart
 * @param {Object} [options.atMost] At most how many spaces the tokens are apart
 * @param {Object} [options.exactly] Exactly how many spaces the tokens are apart
 * @throws {Error} If the options are non-sensical
 */
Function (anonymous_77)
✓ Was calledTokenAssert.prototype._validateOptions = function(options) {···
    var token = options.token;
    var nextToken = options.nextToken;
    var atLeast = options.atLeast;
    var atMost = options.atMost;
    var exactly = options.exactly;

    if (token === nextToken) {
        throw new Error('You cannot specify the same token as both token and nextToken');
    }

    if (atLeast === undefined &&
        atMost === undefined &&
        exactly === undefined) {
        throw new Error('You must specify at least one option');
    }

    if (exactly !== undefined && (atLeast !== undefined || atMost !== undefined)) {
        throw new Error('You cannot specify atLeast or atMost with exactly');
    }

    if (atLeast !== undefined && atMost !== undefined && atMost < atLeast) {
        throw new Error('atLeast and atMost are in conflict');
    }
};
TokenAssert.prototype._validateOptions = function(options) {
    var token = options.token;
    var nextToken = options.nextToken;
    var atLeast = options.atLeast;
    var atMost = options.atMost;
    var exactly = options.exactly;
Branch IfStatement
✓ Positive was executed (if)    if (token === nextToken) {···
        throw new Error('You cannot specify the same token as both token and nextToken');
    }
✓ Negative was executed (else)    }···

    if (atLeast === undefined &&
    if (token === nextToken) {
        throw new Error('You cannot specify the same token as both token and nextToken');
    }
Branch IfStatement
✓ Positive was executed (if)        exactly === undefined) {···
        throw new Error('You must specify at least one option');
    }
✓ Negative was executed (else)    }···

    if (exactly !== undefined && (atLeast !== undefined || atMost !== undefined)) {
Branch LogicalExpression
✓ Was returned        exactly === undefined) {
✓ Was returned    if (atLeast === undefined &&···
        atMost === undefined &&
Branch LogicalExpression
✓ Was returned        atMost === undefined &&
✓ Was returned    if (atLeast === undefined &&
    if (atLeast === undefined &&
        atMost === undefined &&
        exactly === undefined) {
        throw new Error('You must specify at least one option');
    }
Branch IfStatement
✓ Positive was executed (if)    if (exactly !== undefined && (atLeast !== undefined || atMost !== undefined)) {···
        throw new Error('You cannot specify atLeast or atMost with exactly');
    }
✓ Negative was executed (else)    }···

    if (atLeast !== undefined && atMost !== undefined && atMost < atLeast) {
Branch LogicalExpression
✓ Was returned    if (exactly !== undefined && (atLeast !== undefined || atMost !== undefined)) {
✓ Was returned    if (exactly !== undefined && (atLeast !== undefined || atMost !== undefined)) {
Branch LogicalExpression
✓ Was returned    if (exactly !== undefined && (atLeast !== undefined || atMost !== undefined)) {
✓ Was returned    if (exactly !== undefined && (atLeast !== undefined || atMost !== undefined)) {
    if (exactly !== undefined && (atLeast !== undefined || atMost !== undefined)) {
        throw new Error('You cannot specify atLeast or atMost with exactly');
    }
Branch IfStatement
✓ Positive was executed (if)    if (atLeast !== undefined && atMost !== undefined && atMost < atLeast) {···
        throw new Error('atLeast and atMost are in conflict');
    }
✓ Negative was executed (else)    }···
};
Branch LogicalExpression
✓ Was returned    if (atLeast !== undefined && atMost !== undefined && atMost < atLeast) {
✓ Was returned    if (atLeast !== undefined && atMost !== undefined && atMost < atLeast) {
Branch LogicalExpression
✓ Was returned    if (atLeast !== undefined && atMost !== undefined && atMost < atLeast) {
✓ Was returned    if (atLeast !== undefined && atMost !== undefined && atMost < atLeast) {
    if (atLeast !== undefined && atMost !== undefined && atMost < atLeast) {
        throw new Error('atLeast and atMost are in conflict');
    }
};
/**
 * Augments token whitespace to contain the correct number of newlines while preserving indentation
 *
 * @param {Object} options.nextToken
 * @param {Boolean} [options.stickToPreviousToken]
 * @param {Number} lineCount
 */
Function (anonymous_78)
✓ Was calledTokenAssert.prototype._augmentLineCount = function(options, lineCount) {···
    var token = options.nextToken;
    if (lineCount === 0) {
        if (options.stickToPreviousToken) {
            var nextToken = this._file.getNextToken(token, {includeComments: true});
            nextToken.whitespaceBefore = token.whitespaceBefore;
        }
        token.whitespaceBefore = ' ';
        return;
    }

    this._updateWhitespaceByLine(token, function(lines) {
        var currentLineCount = lines.length;
        var lastLine = lines[lines.length - 1];

        if (currentLineCount <= lineCount) {
            // add additional lines that maintain the same indentation as the former last line
            for (; currentLineCount <= lineCount; currentLineCount++) {
                lines[lines.length - 1] = '';
                lines.push(lastLine);
            }
        } else {
            // remove lines and then ensure that the new last line maintains the previous indentation
            lines = lines.slice(0, lineCount + 1);
            lines[lines.length - 1] = lastLine;
        }
        return lines;
    });
};
TokenAssert.prototype._augmentLineCount = function(options, lineCount) {
    var token = options.nextToken;
Branch IfStatement
✓ Positive was executed (if)    if (lineCount === 0) {···
        if (options.stickToPreviousToken) {
            var nextToken = this._file.getNextToken(token, {includeComments: true});
            nextToken.whitespaceBefore = token.whitespaceBefore;
        }
        token.whitespaceBefore = ' ';
        return;
    }
✓ Negative was executed (else)    }···

    this._updateWhitespaceByLine(token, function(lines) {
    if (lineCount === 0) {
Branch IfStatement
✓ Positive was executed (if)        if (options.stickToPreviousToken) {···
            var nextToken = this._file.getNextToken(token, {includeComments: true});
            nextToken.whitespaceBefore = token.whitespaceBefore;
        }
✓ Negative was executed (else)        }···
        token.whitespaceBefore = ' ';
        if (options.stickToPreviousToken) {
            var nextToken = this._file.getNextToken(token, {includeComments: true});
            nextToken.whitespaceBefore = token.whitespaceBefore;
        }
        token.whitespaceBefore = ' ';
        return;
    }
Function (anonymous_79)
✓ Was called    this._updateWhitespaceByLine(token, function(lines) {···
        var currentLineCount = lines.length;
        var lastLine = lines[lines.length - 1];

        if (currentLineCount <= lineCount) {
            // add additional lines that maintain the same indentation as the former last line
            for (; currentLineCount <= lineCount; currentLineCount++) {
                lines[lines.length - 1] = '';
                lines.push(lastLine);
            }
        } else {
            // remove lines and then ensure that the new last line maintains the previous indentation
            lines = lines.slice(0, lineCount + 1);
            lines[lines.length - 1] = lastLine;
        }
        return lines;
    });
    this._updateWhitespaceByLine(token, function(lines) {
        var currentLineCount = lines.length;
        var lastLine = lines[lines.length - 1];
Branch IfStatement
✓ Positive was executed (if)        if (currentLineCount <= lineCount) {···
            // add additional lines that maintain the same indentation as the former last line
            for (; currentLineCount <= lineCount; currentLineCount++) {
                lines[lines.length - 1] = '';
                lines.push(lastLine);
            }
        } else {
✓ Negative was executed (else)        } else {···
            // remove lines and then ensure that the new last line maintains the previous indentation
            lines = lines.slice(0, lineCount + 1);
            lines[lines.length - 1] = lastLine;
        }
        if (currentLineCount <= lineCount) {
            // add additional lines that maintain the same indentation as the former last line
            for (; currentLineCount <= lineCount; currentLineCount++) {
                lines[lines.length - 1] = '';
                lines.push(lastLine);
            }
        } else {
            // remove lines and then ensure that the new last line maintains the previous indentation
            lines = lines.slice(0, lineCount + 1);
            lines[lines.length - 1] = lastLine;
        }
        return lines;
    });
};
/**
 * Requires specific token before given.
 *
 * @param {Object} options.token
 * @param {Object} options.expectedTokenBefore
 * @param {String} [options.message]
 */
Function (anonymous_80)
✓ Was calledTokenAssert.prototype.tokenBefore = function(options) {···
    var token = options.token;
    var actualTokenBefore = this._file.getPrevToken(token);
    var expectedTokenBefore = options.expectedTokenBefore;
    if (!actualTokenBefore) {
        this.emit('error', {
            message: expectedTokenBefore.value + ' was expected before ' + token.value + ' but document start found',
            line: token.loc.start.line,
            column: token.loc.start.column
        });
        return;
    }
    if (
        actualTokenBefore.type !== expectedTokenBefore.type ||
        actualTokenBefore.value !== expectedTokenBefore.value
    ) {
        var message = options.message;
        if (!message) {
            var showTypes = expectedTokenBefore.value === actualTokenBefore.value;
            message =
                expectedTokenBefore.value + (showTypes ? ' (' + expectedTokenBefore.type + ')' : '') +
                ' was expected before ' + token.value +
                ' but ' + actualTokenBefore.value + (showTypes ? ' (' + actualTokenBefore.type + ')' : '') + ' found';
        }
        this.emit('error', {
            message: message,
            line: actualTokenBefore.loc.end.line,
            column: actualTokenBefore.loc.end.column
        });
    }
};
TokenAssert.prototype.tokenBefore = function(options) {
    var token = options.token;
    var actualTokenBefore = this._file.getPrevToken(token);
    var expectedTokenBefore = options.expectedTokenBefore;
Branch IfStatement
✓ Positive was executed (if)    if (!actualTokenBefore) {···
        this.emit('error', {
            message: expectedTokenBefore.value + ' was expected before ' + token.value + ' but document start found',
            line: token.loc.start.line,
            column: token.loc.start.column
        });
        return;
    }
✓ Negative was executed (else)    }···
    if (
    if (!actualTokenBefore) {
        this.emit('error', {
            message: expectedTokenBefore.value + ' was expected before ' + token.value + ' but document start found',
            line: token.loc.start.line,
            column: token.loc.start.column
        });
        return;
    }
Branch IfStatement
✓ Positive was executed (if)    ) {···
        var message = options.message;
        if (!message) {
            var showTypes = expectedTokenBefore.value === actualTokenBefore.value;
            message =
                expectedTokenBefore.value + (showTypes ? ' (' + expectedTokenBefore.type + ')' : '') +
                ' was expected before ' + token.value +
                ' but ' + actualTokenBefore.value + (showTypes ? ' (' + actualTokenBefore.type + ')' : '') + ' found';
        }
        this.emit('error', {
            message: message,
            line: actualTokenBefore.loc.end.line,
            column: actualTokenBefore.loc.end.column
        });
    }
✓ Negative was executed (else)    }···
};
    if (
Branch LogicalExpression
✓ Was returned        actualTokenBefore.value !== expectedTokenBefore.value
✓ Was returned        actualTokenBefore.type !== expectedTokenBefore.type ||
        actualTokenBefore.type !== expectedTokenBefore.type ||
        actualTokenBefore.value !== expectedTokenBefore.value
    ) {
        var message = options.message;
Branch IfStatement
✓ Positive was executed (if)        if (!message) {···
            var showTypes = expectedTokenBefore.value === actualTokenBefore.value;
            message =
                expectedTokenBefore.value + (showTypes ? ' (' + expectedTokenBefore.type + ')' : '') +
                ' was expected before ' + token.value +
                ' but ' + actualTokenBefore.value + (showTypes ? ' (' + actualTokenBefore.type + ')' : '') + ' found';
        }
✓ Negative was executed (else)        }···
        this.emit('error', {
        if (!message) {
            var showTypes = expectedTokenBefore.value === actualTokenBefore.value;
            message =
Branch ConditionalExpression
✓ Positive was returned (? ...)                expectedTokenBefore.value + (showTypes ? ' (' + expectedTokenBefore.type + ')' : '') +
✓ Negative was returned (: ...)                expectedTokenBefore.value + (showTypes ? ' (' + expectedTokenBefore.type + ')' : '') +
                expectedTokenBefore.value + (showTypes ? ' (' + expectedTokenBefore.type + ')' : '') +
                ' was expected before ' + token.value +
Branch ConditionalExpression
✓ Positive was returned (? ...)                ' but ' + actualTokenBefore.value + (showTypes ? ' (' + actualTokenBefore.type + ')' : '') + ' found';
✓ Negative was returned (: ...)                ' but ' + actualTokenBefore.value + (showTypes ? ' (' + actualTokenBefore.type + ')' : '') + ' found';
                ' but ' + actualTokenBefore.value + (showTypes ? ' (' + actualTokenBefore.type + ')' : '') + ' found';
        }
        this.emit('error', {
            message: message,
            line: actualTokenBefore.loc.end.line,
            column: actualTokenBefore.loc.end.column
        });
    }
};
/**
 * Disallows specific token before given.
 *
 * @param {Object} options.token
 * @param {Object} options.expectedTokenBefore
 * @param {String} [options.message]
 */
Function (anonymous_81)
✓ Was calledTokenAssert.prototype.noTokenBefore = function(options) {···
    var token = options.token;
    var actualTokenBefore = this._file.getPrevToken(token);
    if (!actualTokenBefore) {
        // document start
        return;
    }
    var expectedTokenBefore = options.expectedTokenBefore;
    if (actualTokenBefore.type === expectedTokenBefore.type &&
        actualTokenBefore.value === expectedTokenBefore.value
    ) {
        this.emit('error', {
            message: options.message || 'Illegal ' + expectedTokenBefore.value + ' was found before ' + token.value,
            line: actualTokenBefore.loc.end.line,
            column: actualTokenBefore.loc.end.column
        });
    }
};
TokenAssert.prototype.noTokenBefore = function(options) {
    var token = options.token;
    var actualTokenBefore = this._file.getPrevToken(token);
Branch IfStatement
✓ Positive was executed (if)    if (!actualTokenBefore) {···
        // document start
        return;
    }
✓ Negative was executed (else)    }···
    var expectedTokenBefore = options.expectedTokenBefore;
    if (!actualTokenBefore) {
        // document start
        return;
    }
    var expectedTokenBefore = options.expectedTokenBefore;
Branch IfStatement
✓ Positive was executed (if)    ) {···
        this.emit('error', {
            message: options.message || 'Illegal ' + expectedTokenBefore.value + ' was found before ' + token.value,
            line: actualTokenBefore.loc.end.line,
            column: actualTokenBefore.loc.end.column
        });
    }
✓ Negative was executed (else)    }···
};
Branch LogicalExpression
✓ Was returned        actualTokenBefore.value === expectedTokenBefore.value
✓ Was returned    if (actualTokenBefore.type === expectedTokenBefore.type &&
    if (actualTokenBefore.type === expectedTokenBefore.type &&
        actualTokenBefore.value === expectedTokenBefore.value
    ) {
        this.emit('error', {
Branch LogicalExpression
✓ Was returned            message: options.message || 'Illegal ' + expectedTokenBefore.value + ' was found before ' + token.value,
✓ Was returned            message: options.message || 'Illegal ' + expectedTokenBefore.value + ' was found before ' + token.value,
            message: options.message || 'Illegal ' + expectedTokenBefore.value + ' was found before ' + token.value,
            line: actualTokenBefore.loc.end.line,
            column: actualTokenBefore.loc.end.column
        });
    }
};
module.exports = TokenAssert;

js-file.js
var treeIterator = require('./tree-iterator');
/**
 * Operator list which are represented as keywords in token list.
 */
var KEYWORD_OPERATORS = {
    'instanceof': true,
    'in': true
};
/**
 * File representation for JSCS.
 *
 * @name JsFile
 */
Function (anonymous_82)
✓ Was calledvar JsFile = function(filename, source, tree, options) {···
    options = options || {};

    this._filename = filename;
    this._source = source;
    this._tree = tree || {tokens: [], comments: []};

    this._es3 = options.es3 || false;
    this._es6 = options.es6 || false;

    this._lineBreaks = null;
    this._lines = source.split(/\r\n|\r|\n/);

    this._tree.tokens = this._fixEs6Tokens(this._tree.tokens);
    this._tokens = this._buildTokenList(this._tree.tokens, this._tree.comments);
    this._addEOFToken();
    this._applyWhitespaceData(this._tokens, source);

    var tokenIndexes = this._buildTokenIndex(this._tokens);
    this._tokenRangeStartIndex = tokenIndexes.tokenRangeStartIndex;
    this._tokenRangeEndIndex = tokenIndexes.tokenRangeEndIndex;
    this._tokensByLineIndex = tokenIndexes.tokensByLineIndex;

    var nodeIndexes = this._buildNodeIndex();
    this._index = nodeIndexes.nodesByType;
    this._nodesByStartRange = nodeIndexes.nodesByStartRange;

    this._fixEsprimaIdentifiers();

    this._buildDisabledRuleIndex();
};
var JsFile = function(filename, source, tree, options) {
Branch LogicalExpression
✓ Was returned    options = options || {};
✓ Was returned    options = options || {};
    options = options || {};
    this._filename = filename;
    this._source = source;
Branch LogicalExpression
✓ Was returned    this._tree = tree || {tokens: [], comments: []};
✓ Was returned    this._tree = tree || {tokens: [], comments: []};
    this._tree = tree || {tokens: [], comments: []};
Branch LogicalExpression
✓ Was returned    this._es3 = options.es3 || false;
✓ Was returned    this._es3 = options.es3 || false;
    this._es3 = options.es3 || false;
Branch LogicalExpression
✓ Was returned    this._es6 = options.es6 || false;
✓ Was returned    this._es6 = options.es6 || false;
    this._es6 = options.es6 || false;
    this._lineBreaks = null;
    this._lines = source.split(/\r\n|\r|\n/);
    this._tree.tokens = this._fixEs6Tokens(this._tree.tokens);
    this._tokens = this._buildTokenList(this._tree.tokens, this._tree.comments);
    this._addEOFToken();
    this._applyWhitespaceData(this._tokens, source);
    var tokenIndexes = this._buildTokenIndex(this._tokens);
    this._tokenRangeStartIndex = tokenIndexes.tokenRangeStartIndex;
    this._tokenRangeEndIndex = tokenIndexes.tokenRangeEndIndex;
    this._tokensByLineIndex = tokenIndexes.tokensByLineIndex;
    var nodeIndexes = this._buildNodeIndex();
    this._index = nodeIndexes.nodesByType;
    this._nodesByStartRange = nodeIndexes.nodesByStartRange;
    this._fixEsprimaIdentifiers();
    this._buildDisabledRuleIndex();
};
JsFile.prototype = {
    /**
     * Returns the first line break character encountered in the file.
     * Assumes LF if the file is only one line.
     *
     * @returns {String}
     */
Function (anonymous_83)
✓ Was called    getLineBreakStyle: function() {···
        var lineBreaks = this.getLineBreaks();
        return lineBreaks.length ? lineBreaks[0] : '\n';
    },
    getLineBreakStyle: function() {
        var lineBreaks = this.getLineBreaks();
Branch ConditionalExpression
✓ Positive was returned (? ...)        return lineBreaks.length ? lineBreaks[0] : '\n';
✓ Negative was returned (: ...)        return lineBreaks.length ? lineBreaks[0] : '\n';
        return lineBreaks.length ? lineBreaks[0] : '\n';
    },
    /**
     * Returns all line break characters from the file.
     *
     * @returns {String[]}
     */
Function (anonymous_84)
✓ Was called    getLineBreaks: function() {···
        if (this._lineBreaks === null) {
            this._lineBreaks = this._source.match(/\r\n|\r|\n/g) || [];
        }
        return this._lineBreaks;
    },
    getLineBreaks: function() {
Branch IfStatement
✓ Positive was executed (if)        if (this._lineBreaks === null) {···
            this._lineBreaks = this._source.match(/\r\n|\r|\n/g) || [];
        }
✓ Negative was executed (else)        }···
        return this._lineBreaks;
        if (this._lineBreaks === null) {
Branch LogicalExpression
✓ Was returned            this._lineBreaks = this._source.match(/\r\n|\r|\n/g) || [];
✓ Was returned            this._lineBreaks = this._source.match(/\r\n|\r|\n/g) || [];
            this._lineBreaks = this._source.match(/\r\n|\r|\n/g) || [];
        }
        return this._lineBreaks;
    },
    /**
     * Builds an index of disabled rules by starting line for error suppression.
     *
     * @private
     */
Function (anonymous_85)
✓ Was called    _buildDisabledRuleIndex: function() {···
        this._disabledRuleIndex = [];

        var comments = this.getComments();
        var commentRe = /(jscs\s*:\s*(en|dis)able)(.*)/;

        comments.forEach(function(comment) {
            var enabled;
            var parsed = commentRe.exec(comment.value.trim());

            if (!parsed || parsed.index !== 0) {
                return;
            }

            enabled = parsed[2] === 'en';
            this._addToDisabledRuleIndex(enabled, parsed[3], comment.loc.start.line);
        }, this);
    },
    _buildDisabledRuleIndex: function() {
        this._disabledRuleIndex = [];
        var comments = this.getComments();
        var commentRe = /(jscs\s*:\s*(en|dis)able)(.*)/;
Function (anonymous_86)
✓ Was called        comments.forEach(function(comment) {···
            var enabled;
            var parsed = commentRe.exec(comment.value.trim());

            if (!parsed || parsed.index !== 0) {
                return;
            }

            enabled = parsed[2] === 'en';
            this._addToDisabledRuleIndex(enabled, parsed[3], comment.loc.start.line);
        }, this);
        comments.forEach(function(comment) {
            var enabled;
            var parsed = commentRe.exec(comment.value.trim());
Branch IfStatement
✓ Positive was executed (if)            if (!parsed || parsed.index !== 0) {···
                return;
            }
✓ Negative was executed (else)            }···

            enabled = parsed[2] === 'en';
Branch LogicalExpression
✓ Was returned            if (!parsed || parsed.index !== 0) {
✓ Was returned            if (!parsed || parsed.index !== 0) {
            if (!parsed || parsed.index !== 0) {
                return;
            }
            enabled = parsed[2] === 'en';
            this._addToDisabledRuleIndex(enabled, parsed[3], comment.loc.start.line);
        }, this);
    },
    /**
     * Returns whether a specific rule is disabled on the given line.
     *
     * @param {String} ruleName the rule name being tested
     * @param {Number} line the line number being tested
     * @returns {Boolean} true if the rule is enabled
     */
Function (anonymous_87)
✓ Was called    isEnabledRule: function(ruleName, line) {···
        var enabled = true;
        this._disabledRuleIndex.some(function(region) {
            // once the comment we're inspecting occurs after the location of the error,
            // no longer check for whether the state is enabled or disable
            if (region.line > line) {
                return true;
            }

            if (region.rule === ruleName || region.rule === '*') {
                enabled = region.enabled;
            }
        }, this);

        return enabled;
    },
    isEnabledRule: function(ruleName, line) {
        var enabled = true;
Function (anonymous_88)
✓ Was called        this._disabledRuleIndex.some(function(region) {···
            // once the comment we're inspecting occurs after the location of the error,
            // no longer check for whether the state is enabled or disable
            if (region.line > line) {
                return true;
            }

            if (region.rule === ruleName || region.rule === '*') {
                enabled = region.enabled;
            }
        }, this);
        this._disabledRuleIndex.some(function(region) {
            // once the comment we're inspecting occurs after the location of the error,
            // no longer check for whether the state is enabled or disable
Branch IfStatement
✓ Positive was executed (if)            if (region.line > line) {···
                return true;
            }
✓ Negative was executed (else)            }···

            if (region.rule === ruleName || region.rule === '*') {
            if (region.line > line) {
                return true;
            }
Branch IfStatement
✓ Positive was executed (if)            if (region.rule === ruleName || region.rule === '*') {···
                enabled = region.enabled;
            }
✓ Negative was executed (else)            }···
        }, this);
Branch LogicalExpression
✓ Was returned            if (region.rule === ruleName || region.rule === '*') {
✓ Was returned            if (region.rule === ruleName || region.rule === '*') {
            if (region.rule === ruleName || region.rule === '*') {
                enabled = region.enabled;
            }
        }, this);
        return enabled;
    },
    /**
     * Adds rules to the disabled index given a string containing rules (or '' for all).
     *
     * @param {Boolean} enabled whether the rule is disabled or enabled on this line
     * @param {String} rulesStr the string containing specific rules to en/disable
     * @param {Number} line the line the comment appears on
     * @private
     */
Function (anonymous_89)
✓ Was called    _addToDisabledRuleIndex: function(enabled, rulesStr, line) {···
        rulesStr = rulesStr || '*';

        rulesStr.split(',').forEach(function(rule) {
            rule = rule.trim();

            if (!rule) {
                return;
            }

            this._disabledRuleIndex.push({
                rule: rule,
                enabled: enabled,
                line: line
            });
        }, this);
    },
    _addToDisabledRuleIndex: function(enabled, rulesStr, line) {
Branch LogicalExpression
✓ Was returned        rulesStr = rulesStr || '*';
✓ Was returned        rulesStr = rulesStr || '*';
        rulesStr = rulesStr || '*';
Function (anonymous_90)
✓ Was called        rulesStr.split(',').forEach(function(rule) {···
            rule = rule.trim();

            if (!rule) {
                return;
            }

            this._disabledRuleIndex.push({
                rule: rule,
                enabled: enabled,
                line: line
            });
        }, this);
        rulesStr.split(',').forEach(function(rule) {
            rule = rule.trim();
Branch IfStatement
✓ Positive was executed (if)            if (!rule) {···
                return;
            }
✓ Negative was executed (else)            }···

            this._disabledRuleIndex.push({
            if (!rule) {
                return;
            }
            this._disabledRuleIndex.push({
                rule: rule,
                enabled: enabled,
                line: line
            });
        }, this);
    },
    /**
     * Builds token index by starting pos for futher navigation.
     *
     * @param {Object[]} tokens
     * @returns {{tokenRangeStartIndex: {}, tokenRangeEndIndex: {}}}
     * @private
     */
Function (anonymous_91)
✓ Was called    _buildTokenIndex: function(tokens) {···
        var tokenRangeStartIndex = {};
        var tokenRangeEndIndex = {};
        var tokensByLineIndex = {};
        for (var i = 0, l = tokens.length; i < l; i++) {
            var token = tokens[i];

            // tokens by range
            tokenRangeStartIndex[token.range[0]] = i;
            tokenRangeEndIndex[token.range[1]] = i;

            // tokens by line
            var lineNumber = token.loc.start.line;
            if (!tokensByLineIndex[lineNumber]) {
                tokensByLineIndex[lineNumber] = [];
            }
            tokensByLineIndex[lineNumber].push(token);

            token._tokenIndex = i;
        }
        return {
            tokenRangeStartIndex: tokenRangeStartIndex,
            tokenRangeEndIndex: tokenRangeEndIndex,
            tokensByLineIndex: tokensByLineIndex
        };
    },
    _buildTokenIndex: function(tokens) {
        var tokenRangeStartIndex = {};
        var tokenRangeEndIndex = {};
        var tokensByLineIndex = {};
        for (var i = 0, l = tokens.length; i < l; i++) {
            var token = tokens[i];
            // tokens by range
            tokenRangeStartIndex[token.range[0]] = i;
            tokenRangeEndIndex[token.range[1]] = i;
            // tokens by line
            var lineNumber = token.loc.start.line;
Branch IfStatement
✓ Positive was executed (if)            if (!tokensByLineIndex[lineNumber]) {···
                tokensByLineIndex[lineNumber] = [];
            }
✓ Negative was executed (else)            }···
            tokensByLineIndex[lineNumber].push(token);
            if (!tokensByLineIndex[lineNumber]) {
                tokensByLineIndex[lineNumber] = [];
            }
            tokensByLineIndex[lineNumber].push(token);
            token._tokenIndex = i;
        }
        return {
            tokenRangeStartIndex: tokenRangeStartIndex,
            tokenRangeEndIndex: tokenRangeEndIndex,
            tokensByLineIndex: tokensByLineIndex
        };
    },
    /**
     * Returns token using range start from the index.
     *
     * @returns {Object|undefined}
     */
Function (anonymous_92)
✓ Was called    getTokenByRangeStart: function(start) {···
        var tokenIndex = this._tokenRangeStartIndex[start];
        return tokenIndex === undefined ? undefined : this._tokens[tokenIndex];
    },
    getTokenByRangeStart: function(start) {
        var tokenIndex = this._tokenRangeStartIndex[start];
Branch ConditionalExpression
✓ Positive was returned (? ...)        return tokenIndex === undefined ? undefined : this._tokens[tokenIndex];
✓ Negative was returned (: ...)        return tokenIndex === undefined ? undefined : this._tokens[tokenIndex];
        return tokenIndex === undefined ? undefined : this._tokens[tokenIndex];
    },
    /**
     * Returns token using range end from the index.
     *
     * @returns {Object|undefined}
     */
Function (anonymous_93)
✓ Was called    getTokenByRangeEnd: function(end) {···
        var tokenIndex = this._tokenRangeEndIndex[end];
        return tokenIndex === undefined ? undefined : this._tokens[tokenIndex];
    },
    getTokenByRangeEnd: function(end) {
        var tokenIndex = this._tokenRangeEndIndex[end];
Branch ConditionalExpression
✓ Positive was returned (? ...)        return tokenIndex === undefined ? undefined : this._tokens[tokenIndex];
✓ Negative was returned (: ...)        return tokenIndex === undefined ? undefined : this._tokens[tokenIndex];
        return tokenIndex === undefined ? undefined : this._tokens[tokenIndex];
    },
    /**
     * Returns the first token for the node from the AST.
     *
     * @param {Object} node
     * @returns {Object}
     */
Function (anonymous_94)
✓ Was called    getFirstNodeToken: function(node) {···
        return this.getTokenByRangeStart(node.range[0]);
    },
    getFirstNodeToken: function(node) {
        return this.getTokenByRangeStart(node.range[0]);
    },
    /**
     * Returns the last token for the node from the AST.
     *
     * @param {Object} node
     * @returns {Object}
     */
Function (anonymous_95)
✓ Was called    getLastNodeToken: function(node) {···
        return this.getTokenByRangeEnd(node.range[1]);
    },
    getLastNodeToken: function(node) {
        return this.getTokenByRangeEnd(node.range[1]);
    },
    /**
     * Returns the first token for the file.
     *
     * @returns {Object}
     */
Function (anonymous_96)
✓ Was called    getFirstToken: function() {···
        return this._tokens[0];
    },
    getFirstToken: function() {
        return this._tokens[0];
    },
    /**
     * Returns the last token for the file.
     *
     * @returns {Object}
     */
Function (anonymous_97)
✓ Was called    getLastToken: function() {···
        return this._tokens[this._tokens.length - 1];
    },
    getLastToken: function() {
        return this._tokens[this._tokens.length - 1];
    },
    /**
     * Returns the first token before the given.
     *
     * @param {Object} token
     * @param {Object} [options]
     * @param {Boolean} [options.includeComments=false]
     * @returns {Object|undefined}
     */
Function (anonymous_98)
✓ Was called    getPrevToken: function(token, options) {···
        var index = token._tokenIndex - 1;
        if (index < 0) {
            return undefined;
        }

        if (options && options.includeComments) {
            return this._tokens[index];
        }

        do {
            if (!this._tokens[index].isComment) {
                return this._tokens[index];
            }
        } while (--index >= 0);

        return undefined;
    },
    getPrevToken: function(token, options) {
        var index = token._tokenIndex - 1;
Branch IfStatement
✓ Positive was executed (if)        if (index < 0) {···
            return undefined;
        }
✓ Negative was executed (else)        }···

        if (options && options.includeComments) {
        if (index < 0) {
            return undefined;
        }
Branch IfStatement
✓ Positive was executed (if)        if (options && options.includeComments) {···
            return this._tokens[index];
        }
✓ Negative was executed (else)        }···

        do {
Branch LogicalExpression
✓ Was returned        if (options && options.includeComments) {
✓ Was returned        if (options && options.includeComments) {
        if (options && options.includeComments) {
            return this._tokens[index];
        }
        do {
Branch IfStatement
✓ Positive was executed (if)            if (!this._tokens[index].isComment) {···
                return this._tokens[index];
            }
✓ Negative was executed (else)            }···
        } while (--index >= 0);
            if (!this._tokens[index].isComment) {
                return this._tokens[index];
            }
        } while (--index >= 0);
        return undefined;
    },
    /**
     * Returns the first token after the given.
     *
     * @param {Object} token
     * @param {Object} [options]
     * @param {Boolean} [options.includeComments=false]
     * @returns {Object|undefined}
     */
Function (anonymous_99)
✓ Was called    getNextToken: function(token, options) {···
        var index = token._tokenIndex + 1;

        if (index >= this._tokens.length) {
            return undefined;
        }

        if (options && options.includeComments) {
            return this._tokens[index];
        }

        do {
            if (!this._tokens[index].isComment) {
                return this._tokens[index];
            }
        } while (++index < this._tokens.length);
    },
    getNextToken: function(token, options) {
        var index = token._tokenIndex + 1;
Branch IfStatement
✓ Positive was executed (if)        if (index >= this._tokens.length) {···
            return undefined;
        }
✓ Negative was executed (else)        }···

        if (options && options.includeComments) {
        if (index >= this._tokens.length) {
            return undefined;
        }
Branch IfStatement
✓ Positive was executed (if)        if (options && options.includeComments) {···
            return this._tokens[index];
        }
✓ Negative was executed (else)        }···

        do {
Branch LogicalExpression
✓ Was returned        if (options && options.includeComments) {
✓ Was returned        if (options && options.includeComments) {
        if (options && options.includeComments) {
            return this._tokens[index];
        }
        do {
Branch IfStatement
✓ Positive was executed (if)            if (!this._tokens[index].isComment) {···
                return this._tokens[index];
            }
✓ Negative was executed (else)            }···
        } while (++index < this._tokens.length);
            if (!this._tokens[index].isComment) {
                return this._tokens[index];
            }
        } while (++index < this._tokens.length);
    },
    /**
     * Returns the first token before the given which matches type (and value).
     *
     * @param {Object} token
     * @param {String} type
     * @param {String} [value]
     * @returns {Object|undefined}
     */
Function (anonymous_100)
✓ Was called    findPrevToken: function(token, type, value) {···
        var prevToken = this.getPrevToken(token);
        while (prevToken) {
            if (prevToken.type === type && (value === undefined || prevToken.value === value)) {
                return prevToken;
            }
            prevToken = this.getPrevToken(prevToken);
        }
        return prevToken;
    },
    findPrevToken: function(token, type, value) {
        var prevToken = this.getPrevToken(token);
        while (prevToken) {
Branch IfStatement
✓ Positive was executed (if)            if (prevToken.type === type && (value === undefined || prevToken.value === value)) {···
                return prevToken;
            }
✓ Negative was executed (else)            }···
            prevToken = this.getPrevToken(prevToken);
Branch LogicalExpression
✓ Was returned            if (prevToken.type === type && (value === undefined || prevToken.value === value)) {
✓ Was returned            if (prevToken.type === type && (value === undefined || prevToken.value === value)) {
Branch LogicalExpression
✓ Was returned            if (prevToken.type === type && (value === undefined || prevToken.value === value)) {
✓ Was returned            if (prevToken.type === type && (value === undefined || prevToken.value === value)) {
            if (prevToken.type === type && (value === undefined || prevToken.value === value)) {
                return prevToken;
            }
            prevToken = this.getPrevToken(prevToken);
        }
        return prevToken;
    },
    /**
     * Returns the first token after the given which matches type (and value).
     *
     * @param {Object} token
     * @param {String} type
     * @param {String} [value]
     * @returns {Object|undefined}
     */
Function (anonymous_101)
✓ Was called    findNextToken: function(token, type, value) {···
        var nextToken = this.getNextToken(token);
        while (nextToken) {
            if (nextToken.type === type && (value === undefined || nextToken.value === value)) {
                return nextToken;
            }
            nextToken = this.getNextToken(nextToken);
        }
        return nextToken;
    },
    findNextToken: function(token, type, value) {
        var nextToken = this.getNextToken(token);
        while (nextToken) {
Branch IfStatement
✓ Positive was executed (if)            if (nextToken.type === type && (value === undefined || nextToken.value === value)) {···
                return nextToken;
            }
✓ Negative was executed (else)            }···
            nextToken = this.getNextToken(nextToken);
Branch LogicalExpression
✓ Was returned            if (nextToken.type === type && (value === undefined || nextToken.value === value)) {
✓ Was returned            if (nextToken.type === type && (value === undefined || nextToken.value === value)) {
Branch LogicalExpression
✓ Was returned            if (nextToken.type === type && (value === undefined || nextToken.value === value)) {
✓ Was returned            if (nextToken.type === type && (value === undefined || nextToken.value === value)) {
            if (nextToken.type === type && (value === undefined || nextToken.value === value)) {
                return nextToken;
            }
            nextToken = this.getNextToken(nextToken);
        }
        return nextToken;
    },
    /**
     * Returns the first token before the given which matches type (and value).
     *
     * @param {Object} token
     * @param {String} value
     * @returns {Object|undefined}
     */
Function (anonymous_102)
✓ Was called    findPrevOperatorToken: function(token, value) {···
        return this.findPrevToken(token, value in KEYWORD_OPERATORS ? 'Keyword' : 'Punctuator', value);
    },
    findPrevOperatorToken: function(token, value) {
Branch ConditionalExpression
✓ Positive was returned (? ...)        return this.findPrevToken(token, value in KEYWORD_OPERATORS ? 'Keyword' : 'Punctuator', value);
✓ Negative was returned (: ...)        return this.findPrevToken(token, value in KEYWORD_OPERATORS ? 'Keyword' : 'Punctuator', value);
        return this.findPrevToken(token, value in KEYWORD_OPERATORS ? 'Keyword' : 'Punctuator', value);
    },
    /**
     * Returns the first token after the given which matches type (and value).
     *
     * @param {Object} token
     * @param {String} value
     * @returns {Object|undefined}
     */
Function (anonymous_103)
✓ Was called    findNextOperatorToken: function(token, value) {···
        return this.findNextToken(token, value in KEYWORD_OPERATORS ? 'Keyword' : 'Punctuator', value);
    },
    findNextOperatorToken: function(token, value) {
Branch ConditionalExpression
✓ Positive was returned (? ...)        return this.findNextToken(token, value in KEYWORD_OPERATORS ? 'Keyword' : 'Punctuator', value);
✓ Negative was returned (: ...)        return this.findNextToken(token, value in KEYWORD_OPERATORS ? 'Keyword' : 'Punctuator', value);
        return this.findNextToken(token, value in KEYWORD_OPERATORS ? 'Keyword' : 'Punctuator', value);
    },
    /**
     * Iterates through the token tree using tree iterator.
     * Calls passed function for every token.
     *
     * @param {Function} cb
     * @param {Object} [tree]
     */
Function (anonymous_104)
✓ Was called    iterate: function(cb, tree) {···
        return treeIterator.iterate(tree || this._tree, cb);
    },
    iterate: function(cb, tree) {
Branch LogicalExpression
✓ Was returned        return treeIterator.iterate(tree || this._tree, cb);
✓ Was returned        return treeIterator.iterate(tree || this._tree, cb);
        return treeIterator.iterate(tree || this._tree, cb);
    },
    /**
     * Returns node by its range position
     *
     * @returns {Object}
     */
Function (anonymous_105)
✓ Was called    getNodeByRange: function(number) {···
        var result = {};
        this.iterate(function(node) {
            if (number >= node.range[0] && number < node.range[1]) {
                result = node;
            }
            if (number < node.range[0]) {
                return false;
            }
        });
        return result;
    },
    getNodeByRange: function(number) {
        var result = {};
Function (anonymous_106)
✓ Was called        this.iterate(function(node) {···
            if (number >= node.range[0] && number < node.range[1]) {
                result = node;
            }
            if (number < node.range[0]) {
                return false;
            }
        });
        this.iterate(function(node) {
Branch IfStatement
✓ Positive was executed (if)            if (number >= node.range[0] && number < node.range[1]) {···
                result = node;
            }
✓ Negative was executed (else)            }···
            if (number < node.range[0]) {
Branch LogicalExpression
✓ Was returned            if (number >= node.range[0] && number < node.range[1]) {
✓ Was returned            if (number >= node.range[0] && number < node.range[1]) {
            if (number >= node.range[0] && number < node.range[1]) {
                result = node;
            }
Branch IfStatement
✓ Positive was executed (if)            if (number < node.range[0]) {···
                return false;
            }
✓ Negative was executed (else)            }···
        });
            if (number < node.range[0]) {
                return false;
            }
        });
        return result;
    },
    /**
     * Returns nodes by range start index from earlier built index.
     *
     * @param {Object} token
     * @returns {Object[]}
     */
Function (anonymous_107)
✓ Was called    getNodesByFirstToken: function(token) {···
        var result = [];
        if (token && token.range && token.range[0] >= 0) {
            var nodes = this._nodesByStartRange[token.range[0]];
            if (nodes) {
                result = result.concat(nodes);
            }
        }
        return result;
    },
    getNodesByFirstToken: function(token) {
        var result = [];
Branch IfStatement
✓ Positive was executed (if)        if (token && token.range && token.range[0] >= 0) {···
            var nodes = this._nodesByStartRange[token.range[0]];
            if (nodes) {
                result = result.concat(nodes);
            }
        }
✓ Negative was executed (else)        }···
        return result;
Branch LogicalExpression
✓ Was returned        if (token && token.range && token.range[0] >= 0) {
✓ Was returned        if (token && token.range && token.range[0] >= 0) {
Branch LogicalExpression
✓ Was returned        if (token && token.range && token.range[0] >= 0) {
✓ Was returned        if (token && token.range && token.range[0] >= 0) {
        if (token && token.range && token.range[0] >= 0) {
            var nodes = this._nodesByStartRange[token.range[0]];
Branch IfStatement
✓ Positive was executed (if)            if (nodes) {···
                result = result.concat(nodes);
            }
✓ Negative was executed (else)            }···
        }
            if (nodes) {
                result = result.concat(nodes);
            }
        }
        return result;
    },
    /**
     * Returns nodes by type(s) from earlier built index.
     *
     * @param {String|String[]} type
     * @returns {Object[]}
     */
Function (anonymous_108)
✓ Was called    getNodesByType: function(type) {···
        if (typeof type === 'string') {
            return this._index[type] || [];
        } else {
            var result = [];
            for (var i = 0, l = type.length; i < l; i++) {
                var nodes = this._index[type[i]];
                if (nodes) {
                    result = result.concat(nodes);
                }
            }
            return result;
        }
    },
    getNodesByType: function(type) {
Branch IfStatement
✓ Positive was executed (if)        if (typeof type === 'string') {···
            return this._index[type] || [];
        } else {
✓ Negative was executed (else)        } else {···
            var result = [];
            for (var i = 0, l = type.length; i < l; i++) {
                var nodes = this._index[type[i]];
                if (nodes) {
                    result = result.concat(nodes);
                }
            }
            return result;
        }
        if (typeof type === 'string') {
Branch LogicalExpression
✓ Was returned            return this._index[type] || [];
✓ Was returned            return this._index[type] || [];
            return this._index[type] || [];
        } else {
            var result = [];
            for (var i = 0, l = type.length; i < l; i++) {
                var nodes = this._index[type[i]];
Branch IfStatement
✓ Positive was executed (if)                if (nodes) {···
                    result = result.concat(nodes);
                }
✓ Negative was executed (else)                }···
            }
                if (nodes) {
                    result = result.concat(nodes);
                }
            }
            return result;
        }
    },
    /**
     * Iterates nodes by type(s) from earlier built index.
     * Calls passed function for every matched node.
     *
     * @param {String|String[]} type
     * @param {Function} cb
     */
Function (anonymous_109)
✓ Was called    iterateNodesByType: function(type, cb) {···
        return this.getNodesByType(type).forEach(cb);
    },
    iterateNodesByType: function(type, cb) {
        return this.getNodesByType(type).forEach(cb);
    },
    /**
     * Iterates tokens by type(s) from the token array.
     * Calls passed function for every matched token.
     *
     * @param {String|String[]} type
     * @param {Function} cb
     */
Function (anonymous_110)
✓ Was called    iterateTokensByType: function(type, cb) {···
        var types = (typeof type === 'string') ? [type] : type;
        var typeIndex = {};
        types.forEach(function(type) {
            typeIndex[type] = true;
        });

        this.getTokens().forEach(function(token, index, tokens) {
            if (typeIndex[token.type]) {
                cb(token, index, tokens);
            }
        });
    },
    iterateTokensByType: function(type, cb) {
Branch ConditionalExpression
✓ Positive was returned (? ...)        var types = (typeof type === 'string') ? [type] : type;
✓ Negative was returned (: ...)        var types = (typeof type === 'string') ? [type] : type;
        var types = (typeof type === 'string') ? [type] : type;
        var typeIndex = {};
Function (anonymous_111)
✓ Was called        types.forEach(function(type) {···
            typeIndex[type] = true;
        });
        types.forEach(function(type) {
            typeIndex[type] = true;
        });
Function (anonymous_112)
✓ Was called        this.getTokens().forEach(function(token, index, tokens) {···
            if (typeIndex[token.type]) {
                cb(token, index, tokens);
            }
        });
        this.getTokens().forEach(function(token, index, tokens) {
Branch IfStatement
✓ Positive was executed (if)            if (typeIndex[token.type]) {···
                cb(token, index, tokens);
            }
✓ Negative was executed (else)            }···
        });
            if (typeIndex[token.type]) {
                cb(token, index, tokens);
            }
        });
    },
    /**
     * Iterates token by value from the token array.
     * Calls passed function for every matched token.
     *
     * @param {String|String[]} name
     * @param {Function} cb
     */
Function (anonymous_113)
✓ Was called    iterateTokenByValue: function(name, cb) {···
        var names = (typeof name === 'string') ? [name] : name;
        var nameIndex = {};
        names.forEach(function(type) {
            nameIndex[type] = true;
        });

        this.getTokens().forEach(function(token, index, tokens) {
            if (nameIndex.hasOwnProperty(token.value)) {
                cb(token, index, tokens);
            }
        });
    },
    iterateTokenByValue: function(name, cb) {
Branch ConditionalExpression
✓ Positive was returned (? ...)        var names = (typeof name === 'string') ? [name] : name;
✓ Negative was returned (: ...)        var names = (typeof name === 'string') ? [name] : name;
        var names = (typeof name === 'string') ? [name] : name;
        var nameIndex = {};
Function (anonymous_114)
✓ Was called        names.forEach(function(type) {···
            nameIndex[type] = true;
        });
        names.forEach(function(type) {
            nameIndex[type] = true;
        });
Function (anonymous_115)
✓ Was called        this.getTokens().forEach(function(token, index, tokens) {···
            if (nameIndex.hasOwnProperty(token.value)) {
                cb(token, index, tokens);
            }
        });
        this.getTokens().forEach(function(token, index, tokens) {
Branch IfStatement
✓ Positive was executed (if)            if (nameIndex.hasOwnProperty(token.value)) {···
                cb(token, index, tokens);
            }
✓ Negative was executed (else)            }···
        });
            if (nameIndex.hasOwnProperty(token.value)) {
                cb(token, index, tokens);
            }
        });
    },
    /**
     * Iterates tokens by type and value(s) from the token array.
     * Calls passed function for every matched token.
     *
     * @param {String} type
     * @param {String|String[]} value
     * @param {Function} cb
     */
Function (anonymous_116)
✓ Was called    iterateTokensByTypeAndValue: function(type, value, cb) {···
        var values = (typeof value === 'string') ? [value] : value;
        var valueIndex = {};
        values.forEach(function(type) {
            valueIndex[type] = true;
        });

        this.getTokens().forEach(function(token, index, tokens) {
            if (token.type === type && valueIndex[token.value]) {
                cb(token, index, tokens);
            }
        });
    },
    iterateTokensByTypeAndValue: function(type, value, cb) {
Branch ConditionalExpression
✓ Positive was returned (? ...)        var values = (typeof value === 'string') ? [value] : value;
✓ Negative was returned (: ...)        var values = (typeof value === 'string') ? [value] : value;
        var values = (typeof value === 'string') ? [value] : value;
        var valueIndex = {};
Function (anonymous_117)
✓ Was called        values.forEach(function(type) {···
            valueIndex[type] = true;
        });
        values.forEach(function(type) {
            valueIndex[type] = true;
        });
Function (anonymous_118)
✓ Was called        this.getTokens().forEach(function(token, index, tokens) {···
            if (token.type === type && valueIndex[token.value]) {
                cb(token, index, tokens);
            }
        });
        this.getTokens().forEach(function(token, index, tokens) {
Branch IfStatement
✓ Positive was executed (if)            if (token.type === type && valueIndex[token.value]) {···
                cb(token, index, tokens);
            }
✓ Negative was executed (else)            }···
        });
Branch LogicalExpression
✓ Was returned            if (token.type === type && valueIndex[token.value]) {
✓ Was returned            if (token.type === type && valueIndex[token.value]) {
            if (token.type === type && valueIndex[token.value]) {
                cb(token, index, tokens);
            }
        });
    },
    /**
     * Returns first token for the specified line.
     * Line numbers start with 1.
     *
     * @param {Number} lineNumber
     * @param {Object} [options]
     * @param {Boolean} [options.includeComments = false]
     * @returns {Object|undefined}
     */
Function (anonymous_119)
✓ Was called    getFirstTokenOnLine: function(lineNumber, options) {···
        var tokensByLine = this._tokensByLineIndex[lineNumber];

        if (!tokensByLine) {
            return undefined;
        }

        if (options && options.includeComments) {
            return tokensByLine[0];
        }

        for (var i = 0; i < tokensByLine.length; i++) {
            var token = tokensByLine[i];
            if (!token.isComment) {
                return token;
            }
        }

        return undefined;
    },
    getFirstTokenOnLine: function(lineNumber, options) {
        var tokensByLine = this._tokensByLineIndex[lineNumber];
Branch IfStatement
✓ Positive was executed (if)        if (!tokensByLine) {···
            return undefined;
        }
✓ Negative was executed (else)        }···

        if (options && options.includeComments) {
        if (!tokensByLine) {
            return undefined;
        }
Branch IfStatement
✓ Positive was executed (if)        if (options && options.includeComments) {···
            return tokensByLine[0];
        }
✓ Negative was executed (else)        }···

        for (var i = 0; i < tokensByLine.length; i++) {
Branch LogicalExpression
✓ Was returned        if (options && options.includeComments) {
✓ Was returned        if (options && options.includeComments) {
        if (options && options.includeComments) {
            return tokensByLine[0];
        }
        for (var i = 0; i < tokensByLine.length; i++) {
            var token = tokensByLine[i];
Branch IfStatement
✓ Positive was executed (if)            if (!token.isComment) {···
                return token;
            }
✓ Negative was executed (else)            }···
        }
            if (!token.isComment) {
                return token;
            }
        }
        return undefined;
    },
    /**
     * Returns which dialect of JS this file supports.
     *
     * @returns {String}
     */
Function (anonymous_120)
✓ Was called    getDialect: function() {···
        if (this._es6) {
            return 'es6';
        }

        if (this._es3) {
            return 'es3';
        }

        return 'es5';
    },
    getDialect: function() {
Branch IfStatement
✓ Positive was executed (if)        if (this._es6) {···
            return 'es6';
        }
✓ Negative was executed (else)        }···

        if (this._es3) {
        if (this._es6) {
            return 'es6';
        }
Branch IfStatement
✓ Positive was executed (if)        if (this._es3) {···
            return 'es3';
        }
✓ Negative was executed (else)        }···

        return 'es5';
        if (this._es3) {
            return 'es3';
        }
        return 'es5';
    },
    /**
     * Returns string representing contents of the file.
     *
     * @returns {String}
     */
Function (anonymous_121)
✓ Was called    getSource: function() {···
        return this._source;
    },
    getSource: function() {
        return this._source;
    },
    /**
     * Returns token tree, built using esprima.
     *
     * @returns {Object}
     */
Function (anonymous_122)
✓ Was called    getTree: function() {···
        return this._tree;
    },
    getTree: function() {
        return this._tree;
    },
    /**
     * Returns token list, built using esprima.
     *
     * @returns {Object[]}
     */
Function (anonymous_123)
✓ Was called    getTokens: function() {···
        return this._tokens;
    },
    getTokens: function() {
        return this._tokens;
    },
    /**
     * Returns comment token list, built using esprima.
     */
Function (anonymous_124)
✓ Was called    getComments: function() {···
        return this._tree.comments;
    },
    getComments: function() {
        return this._tree.comments;
    },
    /**
     * Returns source filename for this object representation.
     *
     * @returns {String}
     */
Function (anonymous_125)
✓ Was called    getFilename: function() {···
        return this._filename;
    },
    getFilename: function() {
        return this._filename;
    },
    /**
     * Returns array of source lines for the file.
     *
     * @returns {String[]}
     */
Function (anonymous_126)
✓ Was called    getLines: function() {···
        return this._lines;
    },
    getLines: function() {
        return this._lines;
    },
    /**
     * Returns array of source lines for the file with comments removed.
     *
     * @returns {Array}
     */
Function (anonymous_127)
✓ Was called    getLinesWithCommentsRemoved: function() {···
        var lines = this.getLines().concat();

        this.getComments().concat().reverse().forEach(function(comment) {
            var startLine = comment.loc.start.line;
            var startCol = comment.loc.start.column;
            var endLine = comment.loc.end.line;
            var endCol = comment.loc.end.column;
            var i = startLine - 1;

            if (startLine === endLine) {
                lines[i] = lines[i].substring(0, startCol) + lines[i].substring(endCol);
            } else {
                lines[i] = lines[i].substring(0, startCol);
                for (var x = i + 1; x < endLine - 1; x++) {
                    lines[x] = '';
                }
                lines[x] = lines[x].substring(endCol);
            }
        });

        return lines;
    },
    getLinesWithCommentsRemoved: function() {
        var lines = this.getLines().concat();
Function (anonymous_128)
✓ Was called        this.getComments().concat().reverse().forEach(function(comment) {···
            var startLine = comment.loc.start.line;
            var startCol = comment.loc.start.column;
            var endLine = comment.loc.end.line;
            var endCol = comment.loc.end.column;
            var i = startLine - 1;

            if (startLine === endLine) {
                lines[i] = lines[i].substring(0, startCol) + lines[i].substring(endCol);
            } else {
                lines[i] = lines[i].substring(0, startCol);
                for (var x = i + 1; x < endLine - 1; x++) {
                    lines[x] = '';
                }
                lines[x] = lines[x].substring(endCol);
            }
        });
        this.getComments().concat().reverse().forEach(function(comment) {
            var startLine = comment.loc.start.line;
            var startCol = comment.loc.start.column;
            var endLine = comment.loc.end.line;
            var endCol = comment.loc.end.column;
            var i = startLine - 1;
Branch IfStatement
✓ Positive was executed (if)            if (startLine === endLine) {···
                lines[i] = lines[i].substring(0, startCol) + lines[i].substring(endCol);
            } else {
✓ Negative was executed (else)            } else {···
                lines[i] = lines[i].substring(0, startCol);
                for (var x = i + 1; x < endLine - 1; x++) {
                    lines[x] = '';
                }
                lines[x] = lines[x].substring(endCol);
            }
            if (startLine === endLine) {
                lines[i] = lines[i].substring(0, startCol) + lines[i].substring(endCol);
            } else {
                lines[i] = lines[i].substring(0, startCol);
                for (var x = i + 1; x < endLine - 1; x++) {
                    lines[x] = '';
                }
                lines[x] = lines[x].substring(endCol);
            }
        });
        return lines;
    },
    /**
     * Renders JS-file sources using token list.
     *
     * @returns {String}
     */
Function (anonymous_129)
✓ Was called    render: function() {···
        var result = '';

        // For-loop for maximal speed.
        for (var i = 0; i < this._tokens.length; i++) {
            var token = this._tokens[i];

            result += token.whitespaceBefore;

            switch (token.type) {
                // Line-comment: // ...
                case 'Line':
                    result += '//' + token.value;
                    break;

                // Block-comment: /* ... */
                case 'Block':
                    result += '/*' + token.value + '*/';
                    break;

                default:
                    result += token.value;
            }
        }
        return result;
    },
    render: function() {
        var result = '';
        // For-loop for maximal speed.
        for (var i = 0; i < this._tokens.length; i++) {
            var token = this._tokens[i];
            result += token.whitespaceBefore;
Branch SwitchStatement
✓ Was evaluated                case 'Line':···
                    result += '//' + token.value;
                    break;
✓ Was evaluated                case 'Block':···
                    result += '/*' + token.value + '*/';
                    break;
✓ Was evaluated                default:···
                    result += token.value;
            switch (token.type) {
                // Line-comment: // ...
                case 'Line':
                    result += '//' + token.value;
                    break;
                // Block-comment: /* ... */
                case 'Block':
                    result += '/*' + token.value + '*/';
                    break;
                default:
                    result += token.value;
            }
        }
        return result;
    },
    /**
     * Builds token list using both code tokens and comment-tokens.
     *
     * @returns {Object[]}
     * @private
     */
Function (anonymous_130)
✓ Was called    _buildTokenList: function(codeTokens, commentTokens) {···
        var result = [];
        var codeQueue = codeTokens.concat();
        var commentQueue = commentTokens.concat();
        while (codeQueue.length > 0 || commentQueue.length > 0) {
            if (codeQueue.length > 0 && (!commentQueue.length || commentQueue[0].range[0] > codeQueue[0].range[0])) {
                result.push(codeQueue.shift());
            } else {
                var commentToken = commentQueue.shift();
                commentToken.isComment = true;
                result.push(commentToken);
            }
        }
        return result;
    },
    _buildTokenList: function(codeTokens, commentTokens) {
        var result = [];
        var codeQueue = codeTokens.concat();
        var commentQueue = commentTokens.concat();
Branch LogicalExpression
✓ Was returned        while (codeQueue.length > 0 || commentQueue.length > 0) {
✓ Was returned        while (codeQueue.length > 0 || commentQueue.length > 0) {
        while (codeQueue.length > 0 || commentQueue.length > 0) {
Branch IfStatement
✓ Positive was executed (if)            if (codeQueue.length > 0 && (!commentQueue.length || commentQueue[0].range[0] > codeQueue[0].range[0])) {···
                result.push(codeQueue.shift());
            } else {
✓ Negative was executed (else)            } else {···
                var commentToken = commentQueue.shift();
                commentToken.isComment = true;
                result.push(commentToken);
            }
Branch LogicalExpression
✓ Was returned            if (codeQueue.length > 0 && (!commentQueue.length || commentQueue[0].range[0] > codeQueue[0].range[0])) {
✓ Was returned            if (codeQueue.length > 0 && (!commentQueue.length || commentQueue[0].range[0] > codeQueue[0].range[0])) {
Branch LogicalExpression
✓ Was returned            if (codeQueue.length > 0 && (!commentQueue.length || commentQueue[0].range[0] > codeQueue[0].range[0])) {
✓ Was returned            if (codeQueue.length > 0 && (!commentQueue.length || commentQueue[0].range[0] > codeQueue[0].range[0])) {
            if (codeQueue.length > 0 && (!commentQueue.length || commentQueue[0].range[0] > codeQueue[0].range[0])) {
                result.push(codeQueue.shift());
            } else {
                var commentToken = commentQueue.shift();
                commentToken.isComment = true;
                result.push(commentToken);
            }
        }
        return result;
    },
    /**
     * Adds JSCS-specific EOF (end of file) token.
     *
     * @private
     */
Function (anonymous_131)
✓ Was called    _addEOFToken: function() {···
        var loc = {
            line: this._lines.length,
            column: this._lines[this._lines.length - 1].length
        };
        this._tokens.push({
            type: 'EOF',
            value: '',
            range: [this._source.length, this._source.length + 1],
            loc: {start: loc, end: loc}
        });
    },
    _addEOFToken: function() {
        var loc = {
            line: this._lines.length,
            column: this._lines[this._lines.length - 1].length
        };
        this._tokens.push({
            type: 'EOF',
            value: '',
            range: [this._source.length, this._source.length + 1],
            loc: {start: loc, end: loc}
        });
    },
    /**
     * Applies whitespace information to the token list.
     *
     * @param {Object[]} tokens
     * @param {String} source
     * @private
     */
Function (anonymous_132)
✓ Was called    _applyWhitespaceData: function(tokens, source) {···
        var prevPos = 0;
        // For-loop for maximal speed.
        for (var i = 0; i < tokens.length; i++) {
            var token = tokens[i];
            var rangeStart = token.range[0];
            var whitespace;
            if (rangeStart === prevPos) {
                whitespace = '';
            } else {
                whitespace = source.substring(prevPos, rangeStart);
            }
            token.whitespaceBefore = whitespace;
            prevPos = token.range[1];
        }
    },
    _applyWhitespaceData: function(tokens, source) {
        var prevPos = 0;
        // For-loop for maximal speed.
        for (var i = 0; i < tokens.length; i++) {
            var token = tokens[i];
            var rangeStart = token.range[0];
            var whitespace;
Branch IfStatement
✓ Positive was executed (if)            if (rangeStart === prevPos) {···
                whitespace = '';
            } else {
✓ Negative was executed (else)            } else {···
                whitespace = source.substring(prevPos, rangeStart);
            }
            if (rangeStart === prevPos) {
                whitespace = '';
            } else {
                whitespace = source.substring(prevPos, rangeStart);
            }
            token.whitespaceBefore = whitespace;
            prevPos = token.range[1];
        }
    },
    /**
     * Temporary fix (I hope) for esprima tokenizer, which results
     * in duplicate tokens on `export default function() {}`
     * (https://code.google.com/p/esprima/issues/detail?id=631)
     *
     * @param {Object[]} tokens
     * @returns {Object[]}
     * @private
     */
Function (anonymous_133)
✓ Was called    _fixEs6Tokens: function(tokens) {···
        if (this.getDialect() !== 'es6') {
            return tokens;
        }

        var tokenHash = {};
        return tokens.filter(function(token) {
            var hashKey = token.range[0] + '_' + token.range[1];
            var isDuplicate = tokenHash[hashKey];

            tokenHash[hashKey] = true;

            return !isDuplicate;
        });
    },
    _fixEs6Tokens: function(tokens) {
Branch IfStatement
✓ Positive was executed (if)        if (this.getDialect() !== 'es6') {···
            return tokens;
        }
✓ Negative was executed (else)        }···

        var tokenHash = {};
        if (this.getDialect() !== 'es6') {
            return tokens;
        }
        var tokenHash = {};
Function (anonymous_134)
✓ Was called        return tokens.filter(function(token) {···
            var hashKey = token.range[0] + '_' + token.range[1];
            var isDuplicate = tokenHash[hashKey];

            tokenHash[hashKey] = true;

            return !isDuplicate;
        });
        return tokens.filter(function(token) {
            var hashKey = token.range[0] + '_' + token.range[1];
            var isDuplicate = tokenHash[hashKey];
            tokenHash[hashKey] = true;
            return !isDuplicate;
        });
    },
    /**
     * Builds node indexes using
     *  i. node type as the key
     *  ii. node start range as the key
     * @returns {{nodesByType: {}, nodesByStartRange: {}}}
     * @private
     */
Function (anonymous_135)
✓ Was called    _buildNodeIndex: function() {···
        var nodesByType = {};
        var nodesByStartRange = {};
        this.iterate(function(node, parentNode, parentCollection) {
            var type = node.type;

            node.parentNode = parentNode;
            node.parentCollection = parentCollection;
            (nodesByType[type] || (nodesByType[type] = [])).push(node);

            // this part builds a node index that uses node start ranges as the key
            var startRange = node.range[0];
            (nodesByStartRange[startRange] || (nodesByStartRange[startRange] = [])).push(node);
        });
        return {
            nodesByType: nodesByType,
            nodesByStartRange: nodesByStartRange
        };
    },
    _buildNodeIndex: function() {
        var nodesByType = {};
        var nodesByStartRange = {};
Function (anonymous_136)
✓ Was called        this.iterate(function(node, parentNode, parentCollection) {···
            var type = node.type;

            node.parentNode = parentNode;
            node.parentCollection = parentCollection;
            (nodesByType[type] || (nodesByType[type] = [])).push(node);

            // this part builds a node index that uses node start ranges as the key
            var startRange = node.range[0];
            (nodesByStartRange[startRange] || (nodesByStartRange[startRange] = [])).push(node);
        });
        this.iterate(function(node, parentNode, parentCollection) {
            var type = node.type;
            node.parentNode = parentNode;
            node.parentCollection = parentCollection;
Branch LogicalExpression
✓ Was returned            (nodesByType[type] || (nodesByType[type] = [])).push(node);
✓ Was returned            (nodesByType[type] || (nodesByType[type] = [])).push(node);
            (nodesByType[type] || (nodesByType[type] = [])).push(node);
            // this part builds a node index that uses node start ranges as the key
            var startRange = node.range[0];
Branch LogicalExpression
✓ Was returned            (nodesByStartRange[startRange] || (nodesByStartRange[startRange] = [])).push(node);
✓ Was returned            (nodesByStartRange[startRange] || (nodesByStartRange[startRange] = [])).push(node);
            (nodesByStartRange[startRange] || (nodesByStartRange[startRange] = [])).push(node);
        });
        return {
            nodesByType: nodesByType,
            nodesByStartRange: nodesByStartRange
        };
    },
    /**
     * Temporary fix (I hope) for esprima tokenizer
     * (https://code.google.com/p/esprima/issues/detail?id=481)
     * Fixes #83, #180
     * @private
     */
Function (anonymous_137)
✓ Was called    _fixEsprimaIdentifiers: function() {···
        var _this = this;

        this.iterateNodesByType(['Property', 'MemberExpression'], function(node) {
            switch (node.type) {
                case 'Property':
                    convertKeywordToIdentifierIfRequired(node.key);
                    break;
                case 'MemberExpression':
                    convertKeywordToIdentifierIfRequired(node.property);
                    break;
            }
        });

        function convertKeywordToIdentifierIfRequired(node) {
            var token = _this.getTokenByRangeStart(node.range[0]);
            if (token.type === 'Keyword') {
                token.type = 'Identifier';
            }
        }
    }
    _fixEsprimaIdentifiers: function() {
        var _this = this;
Function (anonymous_138)
✓ Was called        this.iterateNodesByType(['Property', 'MemberExpression'], function(node) {···
            switch (node.type) {
                case 'Property':
                    convertKeywordToIdentifierIfRequired(node.key);
                    break;
                case 'MemberExpression':
                    convertKeywordToIdentifierIfRequired(node.property);
                    break;
            }
        });
        this.iterateNodesByType(['Property', 'MemberExpression'], function(node) {
Branch SwitchStatement
✓ Was evaluated                case 'Property':···
                    convertKeywordToIdentifierIfRequired(node.key);
                    break;
✓ Was evaluated                case 'MemberExpression':···
                    convertKeywordToIdentifierIfRequired(node.property);
                    break;
            switch (node.type) {
                case 'Property':
                    convertKeywordToIdentifierIfRequired(node.key);
                    break;
                case 'MemberExpression':
                    convertKeywordToIdentifierIfRequired(node.property);
                    break;
            }
        });
Function convertKeywordToIdentifierIfRequired
✓ Was called        function convertKeywordToIdentifierIfRequired(node) {···
            var token = _this.getTokenByRangeStart(node.range[0]);
            if (token.type === 'Keyword') {
                token.type = 'Identifier';
            }
        }
        function convertKeywordToIdentifierIfRequired(node) {
            var token = _this.getTokenByRangeStart(node.range[0]);
Branch IfStatement
✓ Positive was executed (if)            if (token.type === 'Keyword') {···
                token.type = 'Identifier';
            }
✓ Negative was executed (else)            }···
        }
            if (token.type === 'Keyword') {
                token.type = 'Identifier';
            }
        }
    }
};
/**
 * Parses a JS-file.
 *
 * @param {String} source
 * @param {Object} esprima
 * @param {Object} [esprimaOptions]
 * @returns {Object}
 */
Function (anonymous_140)
✓ Was calledJsFile.parse = function(source, esprima, esprimaOptions) {···
    var finalEsprimaOptions = {
        tolerant: true
    };

    if (esprimaOptions) {
        for (var key in esprimaOptions) {
            finalEsprimaOptions[key] = esprimaOptions[key];
        }
    }

    // Set required options
    finalEsprimaOptions.loc = true;
    finalEsprimaOptions.range = true;
    finalEsprimaOptions.comment = true;
    finalEsprimaOptions.tokens = true;
    finalEsprimaOptions.sourceType = 'module';

    var hashbang = source.indexOf('#!') === 0;
    var tree;

    // Convert bin annotation to a comment
    if (hashbang) {
        source = '//' + source.substr(2);
    }

    var instrumentationData = {};
    var hasInstrumentationData = false;
    // Process special case code like iOS instrumentation imports: `#import 'abc.js';`
    source = source.replace(/^#!?[^\n]+\n/gm, function(str, pos) {
        hasInstrumentationData = true;
        instrumentationData[pos] = str.substring(0, str.length - 1);
        return '//' + str.slice(2);
    });

    tree = esprima.parse(source, finalEsprimaOptions);

    // Change the bin annotation comment
    if (hashbang) {
        tree.comments[0].type = 'Hashbang';
        tree.comments[0].value = '#!' + tree.comments[0].value;
    }

    if (hasInstrumentationData) {
        tree.comments.forEach(function(token) {
            var rangeStart = token.range[0];
            if (instrumentationData.hasOwnProperty(rangeStart)) {
                token.type = 'InstrumentationDirective';
                token.value = instrumentationData[rangeStart];
            }
        });
    }

    return tree;
};
JsFile.parse = function(source, esprima, esprimaOptions) {
    var finalEsprimaOptions = {
        tolerant: true
    };
Branch IfStatement
✓ Positive was executed (if)    if (esprimaOptions) {···
        for (var key in esprimaOptions) {
            finalEsprimaOptions[key] = esprimaOptions[key];
        }
    }
✓ Negative was executed (else)    }···

    // Set required options
    if (esprimaOptions) {
        for (var key in esprimaOptions) {
            finalEsprimaOptions[key] = esprimaOptions[key];
        }
    }
    // Set required options
    finalEsprimaOptions.loc = true;
    finalEsprimaOptions.range = true;
    finalEsprimaOptions.comment = true;
    finalEsprimaOptions.tokens = true;
    finalEsprimaOptions.sourceType = 'module';
    var hashbang = source.indexOf('#!') === 0;
    var tree;
    // Convert bin annotation to a comment
Branch IfStatement
✓ Positive was executed (if)    if (hashbang) {···
        source = '//' + source.substr(2);
    }
✓ Negative was executed (else)    }···

    var instrumentationData = {};
    if (hashbang) {
        source = '//' + source.substr(2);
    }
    var instrumentationData = {};
    var hasInstrumentationData = false;
    // Process special case code like iOS instrumentation imports: `#import 'abc.js';`
Function (anonymous_141)
✓ Was called    source = source.replace(/^#!?[^\n]+\n/gm, function(str, pos) {···
        hasInstrumentationData = true;
        instrumentationData[pos] = str.substring(0, str.length - 1);
        return '//' + str.slice(2);
    });
    source = source.replace(/^#!?[^\n]+\n/gm, function(str, pos) {
        hasInstrumentationData = true;
        instrumentationData[pos] = str.substring(0, str.length - 1);
        return '//' + str.slice(2);
    });
    tree = esprima.parse(source, finalEsprimaOptions);
    // Change the bin annotation comment
Branch IfStatement
✓ Positive was executed (if)    if (hashbang) {···
        tree.comments[0].type = 'Hashbang';
        tree.comments[0].value = '#!' + tree.comments[0].value;
    }
✓ Negative was executed (else)    }···

    if (hasInstrumentationData) {
    if (hashbang) {
        tree.comments[0].type = 'Hashbang';
        tree.comments[0].value = '#!' + tree.comments[0].value;
    }
Branch IfStatement
✓ Positive was executed (if)    if (hasInstrumentationData) {···
        tree.comments.forEach(function(token) {
            var rangeStart = token.range[0];
            if (instrumentationData.hasOwnProperty(rangeStart)) {
                token.type = 'InstrumentationDirective';
                token.value = instrumentationData[rangeStart];
            }
        });
    }
✓ Negative was executed (else)    }···

    return tree;
    if (hasInstrumentationData) {
Function (anonymous_142)
✓ Was called        tree.comments.forEach(function(token) {···
            var rangeStart = token.range[0];
            if (instrumentationData.hasOwnProperty(rangeStart)) {
                token.type = 'InstrumentationDirective';
                token.value = instrumentationData[rangeStart];
            }
        });
        tree.comments.forEach(function(token) {
            var rangeStart = token.range[0];
Branch IfStatement
✓ Positive was executed (if)            if (instrumentationData.hasOwnProperty(rangeStart)) {···
                token.type = 'InstrumentationDirective';
                token.value = instrumentationData[rangeStart];
            }
✓ Negative was executed (else)            }···
        });
            if (instrumentationData.hasOwnProperty(rangeStart)) {
                token.type = 'InstrumentationDirective';
                token.value = instrumentationData[rangeStart];
            }
        });
    }
    return tree;
};
module.exports = JsFile;

tree-iterator.js
var estraverse = require('estraverse');
module.exports = {
    iterate: iterate
};
Function iterate
✓ Was calledfunction iterate(node, cb) {···
    if ('type' in node) {
        estraverse.traverse(node, {
            enter: function(node, parent) {
                var parentCollection = [];

                // parentCollection support
                var path = this.path();
                if (path) {
                    var collectionKey;
                    while (path.length > 0) {
                        var pathElement = path.pop();
                        if (typeof pathElement === 'string') {
                            collectionKey = pathElement;
                            break;
                        }
                    }

                    parentCollection = parent[collectionKey];
                    if (!Array.isArray(parentCollection)) {
                        parentCollection = [parentCollection];
                    }
                }

                if (cb(node, parent, parentCollection) === false) {
                    return estraverse.VisitorOption.Skip;
                }
            },
            keys: {
                JSXIdentifier: [],
                JSXNamespacedName: ['namespace', 'name'],
                JSXMemberExpression: ['object', 'property'],
                JSXEmptyExpression: [],
                JSXExpressionContainer: ['expression'],
                JSXElement: ['openingElement', 'closingElement', 'children'],
                JSXClosingElement: ['name'],
                JSXOpeningElement: ['name', 'attributes'],
                JSXAttribute: ['name', 'value'],
                JSXSpreadAttribute: ['argument'],
                JSXText: null,
                XJSIdentifier: [],
                XJSNamespacedName: ['namespace', 'name'],
                XJSMemberExpression: ['object', 'property'],
                XJSEmptyExpression: [],
                XJSExpressionContainer: ['expression'],
                XJSElement: ['openingElement', 'closingElement', 'children'],
                XJSClosingElement: ['name'],
                XJSOpeningElement: ['name', 'attributes'],
                XJSAttribute: ['name', 'value'],
                XJSSpreadAttribute: ['argument'],
                XJSText: null
            }
        });
    }
}
function iterate(node, cb) {
Branch IfStatement
✓ Positive was executed (if)    if ('type' in node) {···
        estraverse.traverse(node, {
            enter: function(node, parent) {
                var parentCollection = [];

                // parentCollection support
                var path = this.path();
                if (path) {
                    var collectionKey;
                    while (path.length > 0) {
                        var pathElement = path.pop();
                        if (typeof pathElement === 'string') {
                            collectionKey = pathElement;
                            break;
                        }
                    }

                    parentCollection = parent[collectionKey];
                    if (!Array.isArray(parentCollection)) {
                        parentCollection = [parentCollection];
                    }
                }

                if (cb(node, parent, parentCollection) === false) {
                    return estraverse.VisitorOption.Skip;
                }
            },
            keys: {
                JSXIdentifier: [],
                JSXNamespacedName: ['namespace', 'name'],
                JSXMemberExpression: ['object', 'property'],
                JSXEmptyExpression: [],
                JSXExpressionContainer: ['expression'],
                JSXElement: ['openingElement', 'closingElement', 'children'],
                JSXClosingElement: ['name'],
                JSXOpeningElement: ['name', 'attributes'],
                JSXAttribute: ['name', 'value'],
                JSXSpreadAttribute: ['argument'],
                JSXText: null,
                XJSIdentifier: [],
                XJSNamespacedName: ['namespace', 'name'],
                XJSMemberExpression: ['object', 'property'],
                XJSEmptyExpression: [],
                XJSExpressionContainer: ['expression'],
                XJSElement: ['openingElement', 'closingElement', 'children'],
                XJSClosingElement: ['name'],
                XJSOpeningElement: ['name', 'attributes'],
                XJSAttribute: ['name', 'value'],
                XJSSpreadAttribute: ['argument'],
                XJSText: null
            }
        });
    }
✓ Negative was executed (else)    }···
}
    if ('type' in node) {
        estraverse.traverse(node, {
Function (anonymous_144)
✓ Was called            enter: function(node, parent) {···
                var parentCollection = [];

                // parentCollection support
                var path = this.path();
                if (path) {
                    var collectionKey;
                    while (path.length > 0) {
                        var pathElement = path.pop();
                        if (typeof pathElement === 'string') {
                            collectionKey = pathElement;
                            break;
                        }
                    }

                    parentCollection = parent[collectionKey];
                    if (!Array.isArray(parentCollection)) {
                        parentCollection = [parentCollection];
                    }
                }

                if (cb(node, parent, parentCollection) === false) {
                    return estraverse.VisitorOption.Skip;
                }
            },
            enter: function(node, parent) {
                var parentCollection = [];
                // parentCollection support
                var path = this.path();
Branch IfStatement
✓ Positive was executed (if)                if (path) {···
                    var collectionKey;
                    while (path.length > 0) {
                        var pathElement = path.pop();
                        if (typeof pathElement === 'string') {
                            collectionKey = pathElement;
                            break;
                        }
                    }

                    parentCollection = parent[collectionKey];
                    if (!Array.isArray(parentCollection)) {
                        parentCollection = [parentCollection];
                    }
                }
✓ Negative was executed (else)                }···

                if (cb(node, parent, parentCollection) === false) {
                if (path) {
                    var collectionKey;
                    while (path.length > 0) {
                        var pathElement = path.pop();
Branch IfStatement
✓ Positive was executed (if)                        if (typeof pathElement === 'string') {···
                            collectionKey = pathElement;
                            break;
                        }
✓ Negative was executed (else)                        }···
                    }
                        if (typeof pathElement === 'string') {
                            collectionKey = pathElement;
                            break;
                        }
                    }
                    parentCollection = parent[collectionKey];
Branch IfStatement
✓ Positive was executed (if)                    if (!Array.isArray(parentCollection)) {···
                        parentCollection = [parentCollection];
                    }
✓ Negative was executed (else)                    }···
                }
                    if (!Array.isArray(parentCollection)) {
                        parentCollection = [parentCollection];
                    }
                }
Branch IfStatement
✓ Positive was executed (if)                if (cb(node, parent, parentCollection) === false) {···
                    return estraverse.VisitorOption.Skip;
                }
✓ Negative was executed (else)                }···
            },
                if (cb(node, parent, parentCollection) === false) {
                    return estraverse.VisitorOption.Skip;
                }
            },
            keys: {
                JSXIdentifier: [],
                JSXNamespacedName: ['namespace', 'name'],
                JSXMemberExpression: ['object', 'property'],
                JSXEmptyExpression: [],
                JSXExpressionContainer: ['expression'],
                JSXElement: ['openingElement', 'closingElement', 'children'],
                JSXClosingElement: ['name'],
                JSXOpeningElement: ['name', 'attributes'],
                JSXAttribute: ['name', 'value'],
                JSXSpreadAttribute: ['argument'],
                JSXText: null,
                XJSIdentifier: [],
                XJSNamespacedName: ['namespace', 'name'],
                XJSMemberExpression: ['object', 'property'],
                XJSEmptyExpression: [],
                XJSExpressionContainer: ['expression'],
                XJSElement: ['openingElement', 'closingElement', 'children'],
                XJSClosingElement: ['name'],
                XJSOpeningElement: ['name', 'attributes'],
                XJSAttribute: ['name', 'value'],
                XJSSpreadAttribute: ['argument'],
                XJSText: null
            }
        });
    }
}

configuration.js
var assert = require('assert');
var path = require('path');
var minimatch = require('minimatch');
var BUILTIN_OPTIONS = {
    plugins: true,
    preset: true,
    excludeFiles: true,
    additionalRules: true,
    fileExtensions: true,
    maxErrors: true,
    configPath: true,
    esnext: true,
    es3: true,
    esprima: true,
    esprimaOptions: true,
    errorFilter: true,
    verbose: true
};
/**
 * JSCS Configuration.
 * Browser/Rhino-compatible.
 *
 * @name Configuration
 */
Function Configuration
✓ Was calledfunction Configuration() {···
    this._presets = {};
    this._rules = {};
    this._configuredRules = [];
    this._unsupportedRuleNames = [];
    this._fileExtensions = ['.js'];
    this._excludedFileMasks = [];
    this._excludedFileMatchers = [];
    this._ruleSettings = {};
    this._maxErrors = null;
    this._basePath = '.';
    this._overrides = {};
    this._presetName = null;
    this._esnextEnabled = false;
    this._es3Enabled = true;
    this._esprima = null;
    this._esprimaOptions = {};
    this._errorFilter = null;
    this._verbose = null;
}
function Configuration() {
    this._presets = {};
    this._rules = {};
    this._configuredRules = [];
    this._unsupportedRuleNames = [];
    this._fileExtensions = ['.js'];
    this._excludedFileMasks = [];
    this._excludedFileMatchers = [];
    this._ruleSettings = {};
    this._maxErrors = null;
    this._basePath = '.';
    this._overrides = {};
    this._presetName = null;
    this._esnextEnabled = false;
    this._es3Enabled = true;
    this._esprima = null;
    this._esprimaOptions = {};
    this._errorFilter = null;
    this._verbose = null;
}
/**
 * Load settings from a configuration.
 *
 * @param {Object} config
 */
Function (anonymous_146)
✓ Was calledConfiguration.prototype.load = function(config) {···
    this._throwNonCamelCaseErrorIfNeeded(config);

    var overrides = this._overrides;
    var currentConfig = {};

    copyConfiguration(config, currentConfig);
    copyConfiguration(overrides, currentConfig);

    var ruleSettings = this._processConfig(currentConfig);
    var processedSettings = {};

    Object.keys(ruleSettings).forEach(function(optionName) {
        var rule = this._rules[optionName];
        if (rule) {
            var optionValue = ruleSettings[optionName];
            if (optionValue !== null) {
                rule.configure(ruleSettings[optionName]);
                this._configuredRules.push(rule);
                processedSettings[optionName] = ruleSettings[optionName];
            }
        } else {
            this._unsupportedRuleNames.push(optionName);
        }
    }, this);

    this._ruleSettings = processedSettings;
};
Configuration.prototype.load = function(config) {
    this._throwNonCamelCaseErrorIfNeeded(config);
    var overrides = this._overrides;
    var currentConfig = {};
    copyConfiguration(config, currentConfig);
    copyConfiguration(overrides, currentConfig);
    var ruleSettings = this._processConfig(currentConfig);
    var processedSettings = {};
Function (anonymous_147)
✓ Was called    Object.keys(ruleSettings).forEach(function(optionName) {···
        var rule = this._rules[optionName];
        if (rule) {
            var optionValue = ruleSettings[optionName];
            if (optionValue !== null) {
                rule.configure(ruleSettings[optionName]);
                this._configuredRules.push(rule);
                processedSettings[optionName] = ruleSettings[optionName];
            }
        } else {
            this._unsupportedRuleNames.push(optionName);
        }
    }, this);
    Object.keys(ruleSettings).forEach(function(optionName) {
        var rule = this._rules[optionName];
Branch IfStatement
✓ Positive was executed (if)        if (rule) {···
            var optionValue = ruleSettings[optionName];
            if (optionValue !== null) {
                rule.configure(ruleSettings[optionName]);
                this._configuredRules.push(rule);
                processedSettings[optionName] = ruleSettings[optionName];
            }
        } else {
✓ Negative was executed (else)        } else {···
            this._unsupportedRuleNames.push(optionName);
        }
        if (rule) {
            var optionValue = ruleSettings[optionName];
Branch IfStatement
✓ Positive was executed (if)            if (optionValue !== null) {···
                rule.configure(ruleSettings[optionName]);
                this._configuredRules.push(rule);
                processedSettings[optionName] = ruleSettings[optionName];
            }
✓ Negative was executed (else)            }···
        } else {
            if (optionValue !== null) {
                rule.configure(ruleSettings[optionName]);
                this._configuredRules.push(rule);
                processedSettings[optionName] = ruleSettings[optionName];
            }
        } else {
            this._unsupportedRuleNames.push(optionName);
        }
    }, this);
    this._ruleSettings = processedSettings;
};
/**
 * Returns resulting configuration after preset is applied and options are processed.
 *
 * @return {Object}
 */
Function (anonymous_148)
✓ Was calledConfiguration.prototype.getProcessedConfig = function() {···
    var result = {};
    Object.keys(this._ruleSettings).forEach(function(key) {
        result[key] = this._ruleSettings[key];
    }, this);
    result.excludeFiles = this._excludedFileMasks;
    result.fileExtensions = this._fileExtensions;
    result.maxErrors = this._maxErrors;
    result.preset = this._presetName;
    result.esnext = this._esnextEnabled;
    result.es3 = this._es3Enabled;
    result.esprima = this._esprima;
    result.esprimaOptions = this._esprimaOptions;
    result.errorFilter = this._errorFilter;
    return result;
};
Configuration.prototype.getProcessedConfig = function() {
    var result = {};
Function (anonymous_149)
✓ Was called    Object.keys(this._ruleSettings).forEach(function(key) {···
        result[key] = this._ruleSettings[key];
    }, this);
    Object.keys(this._ruleSettings).forEach(function(key) {
        result[key] = this._ruleSettings[key];
    }, this);
    result.excludeFiles = this._excludedFileMasks;
    result.fileExtensions = this._fileExtensions;
    result.maxErrors = this._maxErrors;
    result.preset = this._presetName;
    result.esnext = this._esnextEnabled;
    result.es3 = this._es3Enabled;
    result.esprima = this._esprima;
    result.esprimaOptions = this._esprimaOptions;
    result.errorFilter = this._errorFilter;
    return result;
};
/**
 * Returns list of configured rules.
 *
 * @returns {Rule[]}
 */
Function (anonymous_150)
✓ Was calledConfiguration.prototype.getConfiguredRules = function() {···
    return this._configuredRules;
};
Configuration.prototype.getConfiguredRules = function() {
    return this._configuredRules;
};
/**
 * Returns the list of unsupported rule names.
 *
 * @return {String[]}
 */
Function (anonymous_151)
✓ Was calledConfiguration.prototype.getUnsupportedRuleNames = function() {···
    return this._unsupportedRuleNames;
};
Configuration.prototype.getUnsupportedRuleNames = function() {
    return this._unsupportedRuleNames;
};
/**
 * Returns excluded file mask list.
 *
 * @returns {String[]}
 */
Function (anonymous_152)
✓ Was calledConfiguration.prototype.getExcludedFileMasks = function() {···
    return this._excludedFileMasks;
};
Configuration.prototype.getExcludedFileMasks = function() {
    return this._excludedFileMasks;
};
/**
 * Returns `true` if specified file path is excluded.
 *
 * @param {String} filePath
 * @returns {Boolean}
 */
Function (anonymous_153)
✓ Was calledConfiguration.prototype.isFileExcluded = function(filePath) {···
    filePath = path.resolve(filePath);
    return this._excludedFileMatchers.some(function(matcher) {
        return matcher.match(filePath);
    });
};
Configuration.prototype.isFileExcluded = function(filePath) {
    filePath = path.resolve(filePath);
Function (anonymous_154)
✓ Was called    return this._excludedFileMatchers.some(function(matcher) {···
        return matcher.match(filePath);
    });
    return this._excludedFileMatchers.some(function(matcher) {
        return matcher.match(filePath);
    });
};
/**
 * Returns file extension list.
 *
 * @returns {String[]}
 */
Function (anonymous_155)
✓ Was calledConfiguration.prototype.getFileExtensions = function() {···
    return this._fileExtensions;
};
Configuration.prototype.getFileExtensions = function() {
    return this._fileExtensions;
};
/**
 * Returns maximal error count.
 *
 * @returns {Number|undefined}
 */
Function (anonymous_156)
✓ Was calledConfiguration.prototype.getMaxErrors = function() {···
    return this._maxErrors;
};
Configuration.prototype.getMaxErrors = function() {
    return this._maxErrors;
};
/**
 * Returns `true` if `esnext` option is enabled.
 *
 * @returns {Boolean}
 */
Function (anonymous_157)
✓ Was calledConfiguration.prototype.isESNextEnabled = function() {···
    return this._esnextEnabled;
};
Configuration.prototype.isESNextEnabled = function() {
    return this._esnextEnabled;
};
/**
 * Returns `true` if `es3` option is enabled.
 *
 * @returns {Boolean}
 */
Function (anonymous_158)
✓ Was calledConfiguration.prototype.isES3Enabled = function() {···
    return this._es3Enabled;
};
Configuration.prototype.isES3Enabled = function() {
    return this._es3Enabled;
};
/**
 * Returns `true` if `esprima` option is not null.
 *
 * @returns {Boolean}
 */
Configuration.prototype.hasCustomEsprima = function() {
    return !!this._esprima;
};
/**
 * Returns the custom esprima parser.
 *
 * @returns {Object|null}
 */
Function (anonymous_160)
✗ Was not calledConfiguration.prototype.getCustomEsprima = function() {···
    return this._esprima;
};
Configuration.prototype.getCustomEsprima = function() {
    return this._esprima;
};
/**
 * Returns verbose option.
 *
 * @returns {Object|null}
 */
Function (anonymous_161)
✓ Was calledConfiguration.prototype.getVerbose = function() {···
    return this._verbose || false;
};
Configuration.prototype.getVerbose = function() {
Branch LogicalExpression
✓ Was returned    return this._verbose || false;
✓ Was returned    return this._verbose || false;
    return this._verbose || false;
};
/**
 * Returns custom Esprima options.
 *
 * @returns {Object}
 */
Function (anonymous_162)
✓ Was calledConfiguration.prototype.getEsprimaOptions = function() {···
    return this._esprimaOptions;
};
Configuration.prototype.getEsprimaOptions = function() {
    return this._esprimaOptions;
};
/**
 * Returns the loaded error filter.
 *
 * @returns {Function|null}
 */
Function (anonymous_163)
✓ Was calledConfiguration.prototype.getErrorFilter = function() {···
    return this._errorFilter;
};
Configuration.prototype.getErrorFilter = function() {
    return this._errorFilter;
};
/**
 * Returns base path.
 *
 * @returns {String}
 */
Function (anonymous_164)
✓ Was calledConfiguration.prototype.getBasePath = function() {···
    return this._basePath;
};
Configuration.prototype.getBasePath = function() {
    return this._basePath;
};
/**
 * Overrides specified settings.
 *
 * @param {String} overrides
 */
Function (anonymous_165)
✓ Was calledConfiguration.prototype.override = function(overrides) {···
    Object.keys(overrides).forEach(function(key) {
        this._overrides[key] = overrides[key];
    }, this);
};
Configuration.prototype.override = function(overrides) {
Function (anonymous_166)
✓ Was called    Object.keys(overrides).forEach(function(key) {···
        this._overrides[key] = overrides[key];
    }, this);
    Object.keys(overrides).forEach(function(key) {
        this._overrides[key] = overrides[key];
    }, this);
};
/**
 * returns options, but not rules, from the provided config
 *
 * @param  {Object} config
 * @returns {Object}
 */
Function (anonymous_167)
✓ Was calledConfiguration.prototype._getOptionsFromConfig = function(config) {···
    return Object.keys(config).reduce(function(options, key) {
        if (BUILTIN_OPTIONS[key]) {
            options[key] = config[key];
        }
        return options;
    }, {});
};
Configuration.prototype._getOptionsFromConfig = function(config) {
Function (anonymous_168)
✓ Was called    return Object.keys(config).reduce(function(options, key) {···
        if (BUILTIN_OPTIONS[key]) {
            options[key] = config[key];
        }
        return options;
    }, {});
    return Object.keys(config).reduce(function(options, key) {
Branch IfStatement
✓ Positive was executed (if)        if (BUILTIN_OPTIONS[key]) {···
            options[key] = config[key];
        }
✓ Negative was executed (else)        }···
        return options;
        if (BUILTIN_OPTIONS[key]) {
            options[key] = config[key];
        }
        return options;
    }, {});
};
/**
 * Processes configuration and returns config options.
 *
 * @param {Object} config
 * @returns {Object}
 */
Function (anonymous_169)
✓ Was calledConfiguration.prototype._processConfig = function(config) {···
    var ruleSettings = {};

    // NOTE: options is a separate object to ensure that future options must be added
    // to BUILTIN_OPTIONS to work, which also assures they aren't mistaken for a rule
    var options = this._getOptionsFromConfig(config);

    // Base path
    if (options.configPath) {
        assert(
            typeof options.configPath === 'string',
            '`configPath` option requires string value'
        );
        this._basePath = path.dirname(options.configPath);
    }

    // Load plugins
    if (options.plugins) {
        assert(Array.isArray(options.plugins), '`plugins` option requires array value');
        options.plugins.forEach(this._loadPlugin, this);
    }

    // Apply presets
    var presetName = options.preset;
    if (presetName) {
        this._presetName = presetName;
        assert(typeof presetName === 'string', '`preset` option requires string value');
        var presetData = this._presets[presetName];
        assert(Boolean(presetData), 'Preset "' + presetName + '" does not exist');
        var presetResult = this._processConfig(presetData);
        Object.keys(presetResult).forEach(function(key) {
            ruleSettings[key] = presetResult[key];
        });
    }

    // File extensions
    if (options.fileExtensions) {
        assert(
            typeof options.fileExtensions === 'string' || Array.isArray(options.fileExtensions),
            '`fileExtensions` option requires string or array value'
        );
        this._fileExtensions = [].concat(options.fileExtensions).map(function(ext) {
            return ext.toLowerCase();
        });
    }

    // File excludes
    if (options.excludeFiles) {
        assert(Array.isArray(options.excludeFiles), '`excludeFiles` option requires array value');
        this._excludedFileMasks = options.excludeFiles;
        this._excludedFileMatchers = this._excludedFileMasks.map(function(fileMask) {
            return new minimatch.Minimatch(path.resolve(this._basePath, fileMask), {
                dot: true
            });
        }, this);
    }

    // Additional rules
    if (options.additionalRules) {
        assert(Array.isArray(options.additionalRules), '`additionalRules` option requires array value');
        options.additionalRules.forEach(this._loadAdditionalRule, this);
    }

    if (options.hasOwnProperty('maxErrors')) {
        var maxErrors = options.maxErrors === null ? null : Number(options.maxErrors);
        assert(
            maxErrors > 0 || isNaN(maxErrors) || maxErrors === null,
            '`maxErrors` option requires number or null value'
        );
        this._maxErrors = maxErrors;
    }

    if (options.hasOwnProperty('esnext')) {
        assert(
            typeof options.esnext === 'boolean' || options.esnext === null,
            '`esnext` option requires boolean or null value'
        );
        this._esnextEnabled = Boolean(options.esnext);
    }

    if (options.hasOwnProperty('es3')) {
        assert(
            typeof options.es3 === 'boolean' || options.es3 === null,
            '`es3` option requires boolean or null value'
        );
        this._es3Enabled = Boolean(options.es3);
    }

    if (options.hasOwnProperty('esprima')) {
        this._loadEsprima(options.esprima);
    }

    if (options.hasOwnProperty('esprimaOptions')) {
        this._loadEsprimaOptions(options.esprimaOptions);
    }

    if (options.hasOwnProperty('errorFilter')) {
        this._loadErrorFilter(options.errorFilter);
    }

    if (options.hasOwnProperty('verbose')) {
        this._loadVerbose(options.verbose);
    }

    // NOTE: rule setting must come last in order to
    // override any rules that are loaded from a preset
    Object.keys(config).forEach(function(key) {
        if (!BUILTIN_OPTIONS[key]) {
            ruleSettings[key] = config[key];
        }
    });

    return ruleSettings;
};
Configuration.prototype._processConfig = function(config) {
    var ruleSettings = {};
    // NOTE: options is a separate object to ensure that future options must be added
    // to BUILTIN_OPTIONS to work, which also assures they aren't mistaken for a rule
    var options = this._getOptionsFromConfig(config);
    // Base path
Branch IfStatement
✓ Positive was executed (if)    if (options.configPath) {···
        assert(
            typeof options.configPath === 'string',
            '`configPath` option requires string value'
        );
        this._basePath = path.dirname(options.configPath);
    }
✓ Negative was executed (else)    }···

    // Load plugins
    if (options.configPath) {
        assert(
            typeof options.configPath === 'string',
            '`configPath` option requires string value'
        );
        this._basePath = path.dirname(options.configPath);
    }
    // Load plugins
Branch IfStatement
✓ Positive was executed (if)    if (options.plugins) {···
        assert(Array.isArray(options.plugins), '`plugins` option requires array value');
        options.plugins.forEach(this._loadPlugin, this);
    }
✓ Negative was executed (else)    }···

    // Apply presets
    if (options.plugins) {
        assert(Array.isArray(options.plugins), '`plugins` option requires array value');
        options.plugins.forEach(this._loadPlugin, this);
    }
    // Apply presets
    var presetName = options.preset;
Branch IfStatement
✓ Positive was executed (if)    if (presetName) {···
        this._presetName = presetName;
        assert(typeof presetName === 'string', '`preset` option requires string value');
        var presetData = this._presets[presetName];
        assert(Boolean(presetData), 'Preset "' + presetName + '" does not exist');
        var presetResult = this._processConfig(presetData);
        Object.keys(presetResult).forEach(function(key) {
            ruleSettings[key] = presetResult[key];
        });
    }
✓ Negative was executed (else)    }···

    // File extensions
    if (presetName) {
        this._presetName = presetName;
        assert(typeof presetName === 'string', '`preset` option requires string value');
        var presetData = this._presets[presetName];
        assert(Boolean(presetData), 'Preset "' + presetName + '" does not exist');
        var presetResult = this._processConfig(presetData);
Function (anonymous_170)
✓ Was called        Object.keys(presetResult).forEach(function(key) {···
            ruleSettings[key] = presetResult[key];
        });
        Object.keys(presetResult).forEach(function(key) {
            ruleSettings[key] = presetResult[key];
        });
    }
    // File extensions
Branch IfStatement
✓ Positive was executed (if)    if (options.fileExtensions) {···
        assert(
            typeof options.fileExtensions === 'string' || Array.isArray(options.fileExtensions),
            '`fileExtensions` option requires string or array value'
        );
        this._fileExtensions = [].concat(options.fileExtensions).map(function(ext) {
            return ext.toLowerCase();
        });
    }
✓ Negative was executed (else)    }···

    // File excludes
    if (options.fileExtensions) {
        assert(
Branch LogicalExpression
✓ Was returned            typeof options.fileExtensions === 'string' || Array.isArray(options.fileExtensions),
✓ Was returned            typeof options.fileExtensions === 'string' || Array.isArray(options.fileExtensions),
            typeof options.fileExtensions === 'string' || Array.isArray(options.fileExtensions),
            '`fileExtensions` option requires string or array value'
        );
Function (anonymous_171)
✓ Was called        this._fileExtensions = [].concat(options.fileExtensions).map(function(ext) {···
            return ext.toLowerCase();
        });
        this._fileExtensions = [].concat(options.fileExtensions).map(function(ext) {
            return ext.toLowerCase();
        });
    }
    // File excludes
Branch IfStatement
✓ Positive was executed (if)    if (options.excludeFiles) {···
        assert(Array.isArray(options.excludeFiles), '`excludeFiles` option requires array value');
        this._excludedFileMasks = options.excludeFiles;
        this._excludedFileMatchers = this._excludedFileMasks.map(function(fileMask) {
            return new minimatch.Minimatch(path.resolve(this._basePath, fileMask), {
                dot: true
            });
        }, this);
    }
✓ Negative was executed (else)    }···

    // Additional rules
    if (options.excludeFiles) {
        assert(Array.isArray(options.excludeFiles), '`excludeFiles` option requires array value');
        this._excludedFileMasks = options.excludeFiles;
Function (anonymous_172)
✓ Was called        this._excludedFileMatchers = this._excludedFileMasks.map(function(fileMask) {···
            return new minimatch.Minimatch(path.resolve(this._basePath, fileMask), {
                dot: true
            });
        }, this);
        this._excludedFileMatchers = this._excludedFileMasks.map(function(fileMask) {
            return new minimatch.Minimatch(path.resolve(this._basePath, fileMask), {
                dot: true
            });
        }, this);
    }
    // Additional rules
Branch IfStatement
✓ Positive was executed (if)    if (options.additionalRules) {···
        assert(Array.isArray(options.additionalRules), '`additionalRules` option requires array value');
        options.additionalRules.forEach(this._loadAdditionalRule, this);
    }
✓ Negative was executed (else)    }···

    if (options.hasOwnProperty('maxErrors')) {
    if (options.additionalRules) {
        assert(Array.isArray(options.additionalRules), '`additionalRules` option requires array value');
        options.additionalRules.forEach(this._loadAdditionalRule, this);
    }
Branch IfStatement
✓ Positive was executed (if)    if (options.hasOwnProperty('maxErrors')) {···
        var maxErrors = options.maxErrors === null ? null : Number(options.maxErrors);
        assert(
            maxErrors > 0 || isNaN(maxErrors) || maxErrors === null,
            '`maxErrors` option requires number or null value'
        );
        this._maxErrors = maxErrors;
    }
✓ Negative was executed (else)    }···

    if (options.hasOwnProperty('esnext')) {
    if (options.hasOwnProperty('maxErrors')) {
Branch ConditionalExpression
✓ Positive was returned (? ...)        var maxErrors = options.maxErrors === null ? null : Number(options.maxErrors);
✓ Negative was returned (: ...)        var maxErrors = options.maxErrors === null ? null : Number(options.maxErrors);
        var maxErrors = options.maxErrors === null ? null : Number(options.maxErrors);
        assert(
Branch LogicalExpression
✓ Was returned            maxErrors > 0 || isNaN(maxErrors) || maxErrors === null,
✓ Was returned            maxErrors > 0 || isNaN(maxErrors) || maxErrors === null,
Branch LogicalExpression
✓ Was returned            maxErrors > 0 || isNaN(maxErrors) || maxErrors === null,
✓ Was returned            maxErrors > 0 || isNaN(maxErrors) || maxErrors === null,
            maxErrors > 0 || isNaN(maxErrors) || maxErrors === null,
            '`maxErrors` option requires number or null value'
        );
        this._maxErrors = maxErrors;
    }
Branch IfStatement
✓ Positive was executed (if)    if (options.hasOwnProperty('esnext')) {···
        assert(
            typeof options.esnext === 'boolean' || options.esnext === null,
            '`esnext` option requires boolean or null value'
        );
        this._esnextEnabled = Boolean(options.esnext);
    }
✓ Negative was executed (else)    }···

    if (options.hasOwnProperty('es3')) {
    if (options.hasOwnProperty('esnext')) {
        assert(
Branch LogicalExpression
✓ Was returned            typeof options.esnext === 'boolean' || options.esnext === null,
✓ Was returned            typeof options.esnext === 'boolean' || options.esnext === null,
            typeof options.esnext === 'boolean' || options.esnext === null,
            '`esnext` option requires boolean or null value'
        );
        this._esnextEnabled = Boolean(options.esnext);
    }
Branch IfStatement
✓ Positive was executed (if)    if (options.hasOwnProperty('es3')) {···
        assert(
            typeof options.es3 === 'boolean' || options.es3 === null,
            '`es3` option requires boolean or null value'
        );
        this._es3Enabled = Boolean(options.es3);
    }
✓ Negative was executed (else)    }···

    if (options.hasOwnProperty('esprima')) {
    if (options.hasOwnProperty('es3')) {
        assert(
Branch LogicalExpression
✓ Was returned            typeof options.es3 === 'boolean' || options.es3 === null,
✓ Was returned            typeof options.es3 === 'boolean' || options.es3 === null,
            typeof options.es3 === 'boolean' || options.es3 === null,
            '`es3` option requires boolean or null value'
        );
        this._es3Enabled = Boolean(options.es3);
    }
Branch IfStatement
✗ Positive was not executed (if)    if (options.hasOwnProperty('esprima')) {···
        this._loadEsprima(options.esprima);
    }
✓ Negative was executed (else)    }···

    if (options.hasOwnProperty('esprimaOptions')) {
    if (options.hasOwnProperty('esprima')) {
        this._loadEsprima(options.esprima);
    }
Branch IfStatement
✓ Positive was executed (if)    if (options.hasOwnProperty('esprimaOptions')) {···
        this._loadEsprimaOptions(options.esprimaOptions);
    }
✓ Negative was executed (else)    }···

    if (options.hasOwnProperty('errorFilter')) {
    if (options.hasOwnProperty('esprimaOptions')) {
        this._loadEsprimaOptions(options.esprimaOptions);
    }
Branch IfStatement
✓ Positive was executed (if)    if (options.hasOwnProperty('errorFilter')) {···
        this._loadErrorFilter(options.errorFilter);
    }
✓ Negative was executed (else)    }···

    if (options.hasOwnProperty('verbose')) {
    if (options.hasOwnProperty('errorFilter')) {
        this._loadErrorFilter(options.errorFilter);
    }
Branch IfStatement
✓ Positive was executed (if)    if (options.hasOwnProperty('verbose')) {···
        this._loadVerbose(options.verbose);
    }
✓ Negative was executed (else)    }···

    // NOTE: rule setting must come last in order to
    if (options.hasOwnProperty('verbose')) {
        this._loadVerbose(options.verbose);
    }
    // NOTE: rule setting must come last in order to
    // override any rules that are loaded from a preset
Function (anonymous_173)
✓ Was called    Object.keys(config).forEach(function(key) {···
        if (!BUILTIN_OPTIONS[key]) {
            ruleSettings[key] = config[key];
        }
    });
    Object.keys(config).forEach(function(key) {
Branch IfStatement
✓ Positive was executed (if)        if (!BUILTIN_OPTIONS[key]) {···
            ruleSettings[key] = config[key];
        }
✓ Negative was executed (else)        }···
    });
        if (!BUILTIN_OPTIONS[key]) {
            ruleSettings[key] = config[key];
        }
    });
    return ruleSettings;
};
/**
 * Loads plugin data.
 *
 * @param {function(Configuration)} plugin
 * @protected
 */
Function (anonymous_174)
✓ Was calledConfiguration.prototype._loadPlugin = function(plugin) {···
    assert(typeof plugin === 'function', '`plugin` should be a function');
    plugin(this);
};
Configuration.prototype._loadPlugin = function(plugin) {
    assert(typeof plugin === 'function', '`plugin` should be a function');
    plugin(this);
};
/**
 * Loads an error filter.
 *
 * @param {Function|null} errorFilter
 * @protected
 */
Function (anonymous_175)
✓ Was calledConfiguration.prototype._loadErrorFilter = function(errorFilter) {···
    assert(
        typeof errorFilter === 'function' ||
        errorFilter === null,
        '`errorFilter` option requires a function or null value'
    );
    this._errorFilter = errorFilter;
};
Configuration.prototype._loadErrorFilter = function(errorFilter) {
    assert(
Branch LogicalExpression
✗ Was not returned        errorFilter === null,
✓ Was returned        typeof errorFilter === 'function' ||
        typeof errorFilter === 'function' ||
        errorFilter === null,
        '`errorFilter` option requires a function or null value'
    );
    this._errorFilter = errorFilter;
};
/**
 * Loads verbose option.
 *
 * @param {Boolean|null} verbose
 * @protected
 */
Function (anonymous_176)
✓ Was calledConfiguration.prototype._loadVerbose = function(verbose) {···
    assert(
        typeof verbose === 'boolean' || verbose === null,
        '`verbose` option requires a boolean or null value'
    );
    this._verbose = verbose;
};
Configuration.prototype._loadVerbose = function(verbose) {
    assert(
Branch LogicalExpression
✓ Was returned        typeof verbose === 'boolean' || verbose === null,
✓ Was returned        typeof verbose === 'boolean' || verbose === null,
        typeof verbose === 'boolean' || verbose === null,
        '`verbose` option requires a boolean or null value'
    );
    this._verbose = verbose;
};
/**
 * Loads a custom esprima.
 *
 * @param {Object|null} esprima
 * @protected
 */
Function (anonymous_177)
✗ Was not calledConfiguration.prototype._loadEsprima = function(esprima) {···
    assert(
        (esprima && typeof esprima.parse === 'function') ||
        esprima === null,
        '`esprima` option requires a null value or an object with a parse function'
    );
    this._esprima = esprima;
};
Configuration.prototype._loadEsprima = function(esprima) {
    assert(
Branch LogicalExpression
✗ Was not returned        esprima === null,
✗ Was not returned        (esprima && typeof esprima.parse === 'function') ||
Branch LogicalExpression
✗ Was not returned        (esprima && typeof esprima.parse === 'function') ||
✗ Was not returned        (esprima && typeof esprima.parse === 'function') ||
        (esprima && typeof esprima.parse === 'function') ||
        esprima === null,
        '`esprima` option requires a null value or an object with a parse function'
    );
    this._esprima = esprima;
};
/**
 * Loads custom Esprima options.
 *
 * @param {Object} esprimaOptions
 * @protected
 */
Function (anonymous_178)
✓ Was calledConfiguration.prototype._loadEsprimaOptions = function(esprimaOptions) {···
    assert(typeof esprimaOptions === 'object' && esprimaOptions !== null, '`esprimaOptions` should be an object');
    this._esprimaOptions = esprimaOptions;
};
Configuration.prototype._loadEsprimaOptions = function(esprimaOptions) {
Branch LogicalExpression
✓ Was returned    assert(typeof esprimaOptions === 'object' && esprimaOptions !== null, '`esprimaOptions` should be an object');
✓ Was returned    assert(typeof esprimaOptions === 'object' && esprimaOptions !== null, '`esprimaOptions` should be an object');
    assert(typeof esprimaOptions === 'object' && esprimaOptions !== null, '`esprimaOptions` should be an object');
    this._esprimaOptions = esprimaOptions;
};
/**
 * Includes plugin in the configuration environment.
 *
 * @param {function(Configuration)|*} plugin
 */
Function (anonymous_179)
✓ Was calledConfiguration.prototype.usePlugin = function(plugin) {···
    this._loadPlugin(plugin);
};
Configuration.prototype.usePlugin = function(plugin) {
    this._loadPlugin(plugin);
};
/**
 * Loads additional rule.
 *
 * @param {Rule} additionalRule
 * @protected
 */
Function (anonymous_180)
✓ Was calledConfiguration.prototype._loadAdditionalRule = function(additionalRule) {···
    assert(typeof additionalRule === 'object', '`additionalRule` should be an object');
    this.registerRule(additionalRule);
};
Configuration.prototype._loadAdditionalRule = function(additionalRule) {
    assert(typeof additionalRule === 'object', '`additionalRule` should be an object');
    this.registerRule(additionalRule);
};
/**
 * Throws error for non camel-case options.
 *
 * @param {Object} ruleSettings
 * @protected
 */
Function (anonymous_181)
✓ Was calledConfiguration.prototype._throwNonCamelCaseErrorIfNeeded = function(ruleSettings) {···
    function symbolToUpperCase(s, symbol) {
        return symbol.toUpperCase();
    }
    function fixSettings(originalSettings) {
        var result = {};
        Object.keys(originalSettings).forEach(function(key) {
            var camelCaseName = key.replace(/_([a-zA-Z])/g, symbolToUpperCase);
            var value = originalSettings[key];
            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
                value = fixSettings(value);
            }
            result[camelCaseName] = value;
        });
        return result;
    }

    Object.keys(ruleSettings).forEach(function(key) {
        if (key.indexOf('_') !== -1) {
            throw new Error(
                'JSCS now accepts configuration options in camel case. Sorry for inconvenience. ' +
                'On the bright side, we tried to convert your jscs config to camel case.\n' +
                '----------------------------------------\n' +
                JSON.stringify(fixSettings(ruleSettings), null, 4) +
                '\n----------------------------------------\n'
            );
        }
    });
};
Configuration.prototype._throwNonCamelCaseErrorIfNeeded = function(ruleSettings) {
Function symbolToUpperCase
✓ Was called    function symbolToUpperCase(s, symbol) {···
        return symbol.toUpperCase();
    }
    function symbolToUpperCase(s, symbol) {
        return symbol.toUpperCase();
    }
Function fixSettings
✓ Was called    function fixSettings(originalSettings) {···
        var result = {};
        Object.keys(originalSettings).forEach(function(key) {
            var camelCaseName = key.replace(/_([a-zA-Z])/g, symbolToUpperCase);
            var value = originalSettings[key];
            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
                value = fixSettings(value);
            }
            result[camelCaseName] = value;
        });
        return result;
    }
    function fixSettings(originalSettings) {
        var result = {};
Function (anonymous_184)
✓ Was called        Object.keys(originalSettings).forEach(function(key) {···
            var camelCaseName = key.replace(/_([a-zA-Z])/g, symbolToUpperCase);
            var value = originalSettings[key];
            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
                value = fixSettings(value);
            }
            result[camelCaseName] = value;
        });
        Object.keys(originalSettings).forEach(function(key) {
            var camelCaseName = key.replace(/_([a-zA-Z])/g, symbolToUpperCase);
            var value = originalSettings[key];
Branch IfStatement
✓ Positive was executed (if)            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {···
                value = fixSettings(value);
            }
✓ Negative was executed (else)            }···
            result[camelCaseName] = value;
Branch LogicalExpression
✓ Was returned            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
✓ Was returned            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
Branch LogicalExpression
✓ Was returned            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
✓ Was returned            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
                value = fixSettings(value);
            }
            result[camelCaseName] = value;
        });
        return result;
    }
Function (anonymous_185)
✓ Was called    Object.keys(ruleSettings).forEach(function(key) {···
        if (key.indexOf('_') !== -1) {
            throw new Error(
                'JSCS now accepts configuration options in camel case. Sorry for inconvenience. ' +
                'On the bright side, we tried to convert your jscs config to camel case.\n' +
                '----------------------------------------\n' +
                JSON.stringify(fixSettings(ruleSettings), null, 4) +
                '\n----------------------------------------\n'
            );
        }
    });
    Object.keys(ruleSettings).forEach(function(key) {
Branch IfStatement
✓ Positive was executed (if)        if (key.indexOf('_') !== -1) {···
            throw new Error(
                'JSCS now accepts configuration options in camel case. Sorry for inconvenience. ' +
                'On the bright side, we tried to convert your jscs config to camel case.\n' +
                '----------------------------------------\n' +
                JSON.stringify(fixSettings(ruleSettings), null, 4) +
                '\n----------------------------------------\n'
            );
        }
✓ Negative was executed (else)        }···
    });
        if (key.indexOf('_') !== -1) {
            throw new Error(
                'JSCS now accepts configuration options in camel case. Sorry for inconvenience. ' +
                'On the bright side, we tried to convert your jscs config to camel case.\n' +
                '----------------------------------------\n' +
                JSON.stringify(fixSettings(ruleSettings), null, 4) +
                '\n----------------------------------------\n'
            );
        }
    });
};
/**
 * Adds rule to the collection.
 *
 * @param {Rule|function} rule Rule instance or rule class.
 */
Function (anonymous_186)
✓ Was calledConfiguration.prototype.registerRule = function(rule) {···
    if (typeof rule === 'function') {
        var RuleClass = rule;
        rule = new RuleClass();
    }

    var optionName = rule.getOptionName();
    assert(!this._rules.hasOwnProperty(optionName), 'Rule "' + optionName + '" is already registered');
    this._rules[optionName] = rule;
};
Configuration.prototype.registerRule = function(rule) {
Branch IfStatement
✓ Positive was executed (if)    if (typeof rule === 'function') {···
        var RuleClass = rule;
        rule = new RuleClass();
    }
✓ Negative was executed (else)    }···

    var optionName = rule.getOptionName();
    if (typeof rule === 'function') {
        var RuleClass = rule;
        rule = new RuleClass();
    }
    var optionName = rule.getOptionName();
    assert(!this._rules.hasOwnProperty(optionName), 'Rule "' + optionName + '" is already registered');
    this._rules[optionName] = rule;
};
/**
 * Returns list of registered rules.
 *
 * @returns {Rule[]}
 */
Function (anonymous_187)
✓ Was calledConfiguration.prototype.getRegisteredRules = function() {···
    var rules = this._rules;
    return Object.keys(rules).map(function(ruleOptionName) {
        return rules[ruleOptionName];
    });
};
Configuration.prototype.getRegisteredRules = function() {
    var rules = this._rules;
Function (anonymous_188)
✓ Was called    return Object.keys(rules).map(function(ruleOptionName) {···
        return rules[ruleOptionName];
    });
    return Object.keys(rules).map(function(ruleOptionName) {
        return rules[ruleOptionName];
    });
};
/**
 * Adds preset to the collection.
 *
 * @param {String} presetName
 * @param {Object} presetConfig
 */
Function (anonymous_189)
✓ Was calledConfiguration.prototype.registerPreset = function(presetName, presetConfig) {···
    this._presets[presetName] = presetConfig;
};
Configuration.prototype.registerPreset = function(presetName, presetConfig) {
    this._presets[presetName] = presetConfig;
};
/**
 * Returns registered presets object (key - preset name, value - preset content).
 *
 * @returns {Object}
 */
Function (anonymous_190)
✓ Was calledConfiguration.prototype.getRegisteredPresets = function() {···
    return this._presets;
};
Configuration.prototype.getRegisteredPresets = function() {
    return this._presets;
};
/**
 * Returns `true` if preset with specified name exists.
 *
 * @param {String} presetName
 * @return {Boolean}
 */
Function (anonymous_191)
✓ Was calledConfiguration.prototype.hasPreset = function(presetName) {···
    return this._presets.hasOwnProperty(presetName);
};
Configuration.prototype.hasPreset = function(presetName) {
    return this._presets.hasOwnProperty(presetName);
};
/**
 * Registers built-in Code Style cheking rules.
 */
Function (anonymous_192)
✓ Was calledConfiguration.prototype.registerDefaultRules = function() {···

    /*
        Important!
        These rules are linked explicitly to keep browser-version supported.
    */

    this.registerRule(require('../rules/require-curly-braces'));
    this.registerRule(require('../rules/disallow-curly-braces'));
    this.registerRule(require('../rules/require-multiple-var-decl'));
    this.registerRule(require('../rules/disallow-multiple-var-decl'));
    this.registerRule(require('../rules/disallow-empty-blocks'));
    this.registerRule(require('../rules/require-space-after-keywords'));
    this.registerRule(require('../rules/require-space-before-keywords'));
    this.registerRule(require('../rules/disallow-space-after-keywords'));
    this.registerRule(require('../rules/disallow-space-before-keywords'));
    this.registerRule(require('../rules/require-parentheses-around-iife'));

    /* deprecated rules */
    this.registerRule(require('../rules/require-left-sticked-operators'));
    this.registerRule(require('../rules/disallow-left-sticked-operators'));
    this.registerRule(require('../rules/require-right-sticked-operators'));
    this.registerRule(require('../rules/disallow-right-sticked-operators'));
    this.registerRule(require('../rules/validate-jsdoc'));
    /* deprecated rules (end) */

    this.registerRule(require('../rules/require-operator-before-line-break'));
    this.registerRule(require('../rules/disallow-operator-before-line-break'));
    this.registerRule(require('../rules/disallow-implicit-type-conversion'));
    this.registerRule(require('../rules/require-camelcase-or-uppercase-identifiers'));
    this.registerRule(require('../rules/disallow-keywords'));
    this.registerRule(require('../rules/disallow-multiple-line-breaks'));
    this.registerRule(require('../rules/disallow-multiple-line-strings'));
    this.registerRule(require('../rules/disallow-multiple-spaces'));
    this.registerRule(require('../rules/validate-line-breaks'));
    this.registerRule(require('../rules/validate-quote-marks'));
    this.registerRule(require('../rules/validate-indentation'));
    this.registerRule(require('../rules/disallow-trailing-whitespace'));
    this.registerRule(require('../rules/disallow-mixed-spaces-and-tabs'));
    this.registerRule(require('../rules/require-keywords-on-new-line'));
    this.registerRule(require('../rules/disallow-keywords-on-new-line'));
    this.registerRule(require('../rules/require-line-feed-at-file-end'));
    this.registerRule(require('../rules/maximum-line-length'));
    this.registerRule(require('../rules/require-yoda-conditions'));
    this.registerRule(require('../rules/disallow-yoda-conditions'));
    this.registerRule(require('../rules/require-spaces-inside-brackets'));
    this.registerRule(require('../rules/require-spaces-inside-object-brackets'));
    this.registerRule(require('../rules/require-spaces-inside-array-brackets'));
    this.registerRule(require('../rules/require-spaces-inside-parentheses'));
    this.registerRule(require('../rules/disallow-spaces-inside-brackets'));
    this.registerRule(require('../rules/disallow-spaces-inside-object-brackets'));
    this.registerRule(require('../rules/disallow-spaces-inside-array-brackets'));
    this.registerRule(require('../rules/disallow-spaces-inside-parentheses'));
    this.registerRule(require('../rules/require-blocks-on-newline'));
    this.registerRule(require('../rules/require-space-after-object-keys'));
    this.registerRule(require('../rules/require-space-before-object-values'));
    this.registerRule(require('../rules/disallow-space-after-object-keys'));
    this.registerRule(require('../rules/disallow-space-before-object-values'));
    this.registerRule(require('../rules/disallow-quoted-keys-in-objects'));
    this.registerRule(require('../rules/require-quoted-keys-in-objects'));
    this.registerRule(require('../rules/disallow-dangling-underscores'));
    this.registerRule(require('../rules/require-aligned-object-values'));
    this.registerRule(require('../rules/validate-aligned-function-parameters'));

    this.registerRule(require('../rules/disallow-padding-newlines-after-blocks'));
    this.registerRule(require('../rules/require-padding-newlines-after-blocks'));

    this.registerRule(require('../rules/disallow-padding-newlines-in-blocks'));
    this.registerRule(require('../rules/require-padding-newlines-in-blocks'));
    this.registerRule(require('../rules/require-padding-newlines-in-objects'));
    this.registerRule(require('../rules/disallow-padding-newlines-in-objects'));
    this.registerRule(require('../rules/require-newline-before-block-statements'));
    this.registerRule(require('../rules/disallow-newline-before-block-statements'));

    this.registerRule(require('../rules/require-padding-newlines-before-keywords'));
    this.registerRule(require('../rules/disallow-padding-newlines-before-keywords'));

    this.registerRule(require('../rules/disallow-padding-newlines-before-line-comments'));
    this.registerRule(require('../rules/require-padding-newlines-before-line-comments'));

    this.registerRule(require('../rules/disallow-trailing-comma'));
    this.registerRule(require('../rules/require-trailing-comma'));

    this.registerRule(require('../rules/require-dollar-before-jquery-assignment'));

    this.registerRule(require('../rules/disallow-comma-before-line-break'));
    this.registerRule(require('../rules/require-comma-before-line-break'));

    this.registerRule(require('../rules/disallow-space-before-block-statements.js'));
    this.registerRule(require('../rules/require-space-before-block-statements.js'));

    this.registerRule(require('../rules/disallow-space-before-postfix-unary-operators.js'));
    this.registerRule(require('../rules/require-space-before-postfix-unary-operators.js'));

    this.registerRule(require('../rules/disallow-space-after-prefix-unary-operators.js'));
    this.registerRule(require('../rules/require-space-after-prefix-unary-operators.js'));

    this.registerRule(require('../rules/disallow-space-before-binary-operators'));
    this.registerRule(require('../rules/require-space-before-binary-operators'));

    this.registerRule(require('../rules/disallow-space-after-binary-operators'));
    this.registerRule(require('../rules/require-space-after-binary-operators'));

    this.registerRule(require('../rules/require-spaces-in-conditional-expression'));
    this.registerRule(require('../rules/disallow-spaces-in-conditional-expression'));

    this.registerRule(require('../rules/require-spaces-in-function'));
    this.registerRule(require('../rules/disallow-spaces-in-function'));
    this.registerRule(require('../rules/require-spaces-in-function-expression'));
    this.registerRule(require('../rules/disallow-spaces-in-function-expression'));
    this.registerRule(require('../rules/require-spaces-in-anonymous-function-expression'));
    this.registerRule(require('../rules/disallow-spaces-in-anonymous-function-expression'));
    this.registerRule(require('../rules/require-spaces-in-named-function-expression'));
    this.registerRule(require('../rules/disallow-spaces-in-named-function-expression'));
    this.registerRule(require('../rules/require-spaces-in-function-declaration'));
    this.registerRule(require('../rules/disallow-spaces-in-function-declaration'));

    this.registerRule(require('../rules/require-spaces-in-call-expression'));
    this.registerRule(require('../rules/disallow-spaces-in-call-expression'));

    this.registerRule(require('../rules/validate-parameter-separator'));
    this.registerRule(require('../rules/require-space-between-arguments'));
    this.registerRule(require('../rules/disallow-space-between-arguments'));

    this.registerRule(require('../rules/require-capitalized-constructors'));

    this.registerRule(require('../rules/safe-context-keyword'));

    this.registerRule(require('../rules/require-dot-notation'));

    this.registerRule(require('../rules/require-space-after-line-comment'));
    this.registerRule(require('../rules/disallow-space-after-line-comment'));

    this.registerRule(require('../rules/require-anonymous-functions'));
    this.registerRule(require('../rules/disallow-anonymous-functions'));
    this.registerRule(require('../rules/require-named-unassigned-functions'));
    this.registerRule(require('../rules/disallow-named-unassigned-functions'));

    this.registerRule(require('../rules/require-function-declarations'));
    this.registerRule(require('../rules/disallow-function-declarations'));

    this.registerRule(require('../rules/require-capitalized-comments'));
    this.registerRule(require('../rules/disallow-capitalized-comments'));

    this.registerRule(require('../rules/require-line-break-after-variable-assignment'));
    this.registerRule(require('../rules/require-padding-newline-after-variable-declaration'));

    this.registerRule(require('../rules/disallow-padding-newlines-after-use-strict'));
    this.registerRule(require('../rules/require-padding-newlines-after-use-strict'));

    this.registerRule(require('../rules/disallow-padding-newlines-before-export'));
    this.registerRule(require('../rules/require-padding-newlines-before-export'));

    this.registerRule(require('../rules/require-semicolons'));
    this.registerRule(require('../rules/disallow-semicolons'));

    this.registerRule(require('../rules/require-spaces-in-for-statement'));
    this.registerRule(require('../rules/disallow-spaces-in-for-statement'));

    this.registerRule(require('../rules/disallow-keywords-in-comments'));

    this.registerRule(require('../rules/disallow-identifier-names'));

    this.registerRule(require('../rules/maximum-number-of-lines'));

    this.registerRule(require('../rules/validate-newline-after-array-elements'));

    this.registerRule(require('../rules/disallow-not-operators-in-conditionals'));
};
Configuration.prototype.registerDefaultRules = function() {
    /*
        Important!
        These rules are linked explicitly to keep browser-version supported.
    */
    this.registerRule(require('../rules/require-curly-braces'));
    this.registerRule(require('../rules/disallow-curly-braces'));
    this.registerRule(require('../rules/require-multiple-var-decl'));
    this.registerRule(require('../rules/disallow-multiple-var-decl'));
    this.registerRule(require('../rules/disallow-empty-blocks'));
    this.registerRule(require('../rules/require-space-after-keywords'));
    this.registerRule(require('../rules/require-space-before-keywords'));
    this.registerRule(require('../rules/disallow-space-after-keywords'));
    this.registerRule(require('../rules/disallow-space-before-keywords'));
    this.registerRule(require('../rules/require-parentheses-around-iife'));
    /* deprecated rules */
    this.registerRule(require('../rules/require-left-sticked-operators'));
    this.registerRule(require('../rules/disallow-left-sticked-operators'));
    this.registerRule(require('../rules/require-right-sticked-operators'));
    this.registerRule(require('../rules/disallow-right-sticked-operators'));
    this.registerRule(require('../rules/validate-jsdoc'));
    /* deprecated rules (end) */
    this.registerRule(require('../rules/require-operator-before-line-break'));
    this.registerRule(require('../rules/disallow-operator-before-line-break'));
    this.registerRule(require('../rules/disallow-implicit-type-conversion'));
    this.registerRule(require('../rules/require-camelcase-or-uppercase-identifiers'));
    this.registerRule(require('../rules/disallow-keywords'));
    this.registerRule(require('../rules/disallow-multiple-line-breaks'));
    this.registerRule(require('../rules/disallow-multiple-line-strings'));
    this.registerRule(require('../rules/disallow-multiple-spaces'));
    this.registerRule(require('../rules/validate-line-breaks'));
    this.registerRule(require('../rules/validate-quote-marks'));
    this.registerRule(require('../rules/validate-indentation'));
    this.registerRule(require('../rules/disallow-trailing-whitespace'));
    this.registerRule(require('../rules/disallow-mixed-spaces-and-tabs'));
    this.registerRule(require('../rules/require-keywords-on-new-line'));
    this.registerRule(require('../rules/disallow-keywords-on-new-line'));
    this.registerRule(require('../rules/require-line-feed-at-file-end'));
    this.registerRule(require('../rules/maximum-line-length'));
    this.registerRule(require('../rules/require-yoda-conditions'));
    this.registerRule(require('../rules/disallow-yoda-conditions'));
    this.registerRule(require('../rules/require-spaces-inside-brackets'));
    this.registerRule(require('../rules/require-spaces-inside-object-brackets'));
    this.registerRule(require('../rules/require-spaces-inside-array-brackets'));
    this.registerRule(require('../rules/require-spaces-inside-parentheses'));
    this.registerRule(require('../rules/disallow-spaces-inside-brackets'));
    this.registerRule(require('../rules/disallow-spaces-inside-object-brackets'));
    this.registerRule(require('../rules/disallow-spaces-inside-array-brackets'));
    this.registerRule(require('../rules/disallow-spaces-inside-parentheses'));
    this.registerRule(require('../rules/require-blocks-on-newline'));
    this.registerRule(require('../rules/require-space-after-object-keys'));
    this.registerRule(require('../rules/require-space-before-object-values'));
    this.registerRule(require('../rules/disallow-space-after-object-keys'));
    this.registerRule(require('../rules/disallow-space-before-object-values'));
    this.registerRule(require('../rules/disallow-quoted-keys-in-objects'));
    this.registerRule(require('../rules/require-quoted-keys-in-objects'));
    this.registerRule(require('../rules/disallow-dangling-underscores'));
    this.registerRule(require('../rules/require-aligned-object-values'));
    this.registerRule(require('../rules/validate-aligned-function-parameters'));
    this.registerRule(require('../rules/disallow-padding-newlines-after-blocks'));
    this.registerRule(require('../rules/require-padding-newlines-after-blocks'));
    this.registerRule(require('../rules/disallow-padding-newlines-in-blocks'));
    this.registerRule(require('../rules/require-padding-newlines-in-blocks'));
    this.registerRule(require('../rules/require-padding-newlines-in-objects'));
    this.registerRule(require('../rules/disallow-padding-newlines-in-objects'));
    this.registerRule(require('../rules/require-newline-before-block-statements'));
    this.registerRule(require('../rules/disallow-newline-before-block-statements'));
    this.registerRule(require('../rules/require-padding-newlines-before-keywords'));
    this.registerRule(require('../rules/disallow-padding-newlines-before-keywords'));
    this.registerRule(require('../rules/disallow-padding-newlines-before-line-comments'));
    this.registerRule(require('../rules/require-padding-newlines-before-line-comments'));
    this.registerRule(require('../rules/disallow-trailing-comma'));
    this.registerRule(require('../rules/require-trailing-comma'));
    this.registerRule(require('../rules/require-dollar-before-jquery-assignment'));
    this.registerRule(require('../rules/disallow-comma-before-line-break'));
    this.registerRule(require('../rules/require-comma-before-line-break'));
    this.registerRule(require('../rules/disallow-space-before-block-statements.js'));
    this.registerRule(require('../rules/require-space-before-block-statements.js'));
    this.registerRule(require('../rules/disallow-space-before-postfix-unary-operators.js'));
    this.registerRule(require('../rules/require-space-before-postfix-unary-operators.js'));
    this.registerRule(require('../rules/disallow-space-after-prefix-unary-operators.js'));
    this.registerRule(require('../rules/require-space-after-prefix-unary-operators.js'));
    this.registerRule(require('../rules/disallow-space-before-binary-operators'));
    this.registerRule(require('../rules/require-space-before-binary-operators'));
    this.registerRule(require('../rules/disallow-space-after-binary-operators'));
    this.registerRule(require('../rules/require-space-after-binary-operators'));
    this.registerRule(require('../rules/require-spaces-in-conditional-expression'));
    this.registerRule(require('../rules/disallow-spaces-in-conditional-expression'));
    this.registerRule(require('../rules/require-spaces-in-function'));
    this.registerRule(require('../rules/disallow-spaces-in-function'));
    this.registerRule(require('../rules/require-spaces-in-function-expression'));
    this.registerRule(require('../rules/disallow-spaces-in-function-expression'));
    this.registerRule(require('../rules/require-spaces-in-anonymous-function-expression'));
    this.registerRule(require('../rules/disallow-spaces-in-anonymous-function-expression'));
    this.registerRule(require('../rules/require-spaces-in-named-function-expression'));
    this.registerRule(require('../rules/disallow-spaces-in-named-function-expression'));
    this.registerRule(require('../rules/require-spaces-in-function-declaration'));
    this.registerRule(require('../rules/disallow-spaces-in-function-declaration'));
    this.registerRule(require('../rules/require-spaces-in-call-expression'));
    this.registerRule(require('../rules/disallow-spaces-in-call-expression'));
    this.registerRule(require('../rules/validate-parameter-separator'));
    this.registerRule(require('../rules/require-space-between-arguments'));
    this.registerRule(require('../rules/disallow-space-between-arguments'));
    this.registerRule(require('../rules/require-capitalized-constructors'));
    this.registerRule(require('../rules/safe-context-keyword'));
    this.registerRule(require('../rules/require-dot-notation'));
    this.registerRule(require('../rules/require-space-after-line-comment'));
    this.registerRule(require('../rules/disallow-space-after-line-comment'));
    this.registerRule(require('../rules/require-anonymous-functions'));
    this.registerRule(require('../rules/disallow-anonymous-functions'));
    this.registerRule(require('../rules/require-named-unassigned-functions'));
    this.registerRule(require('../rules/disallow-named-unassigned-functions'));
    this.registerRule(require('../rules/require-function-declarations'));
    this.registerRule(require('../rules/disallow-function-declarations'));
    this.registerRule(require('../rules/require-capitalized-comments'));
    this.registerRule(require('../rules/disallow-capitalized-comments'));
    this.registerRule(require('../rules/require-line-break-after-variable-assignment'));
    this.registerRule(require('../rules/require-padding-newline-after-variable-declaration'));
    this.registerRule(require('../rules/disallow-padding-newlines-after-use-strict'));
    this.registerRule(require('../rules/require-padding-newlines-after-use-strict'));
    this.registerRule(require('../rules/disallow-padding-newlines-before-export'));
    this.registerRule(require('../rules/require-padding-newlines-before-export'));
    this.registerRule(require('../rules/require-semicolons'));
    this.registerRule(require('../rules/disallow-semicolons'));
    this.registerRule(require('../rules/require-spaces-in-for-statement'));
    this.registerRule(require('../rules/disallow-spaces-in-for-statement'));
    this.registerRule(require('../rules/disallow-keywords-in-comments'));
    this.registerRule(require('../rules/disallow-identifier-names'));
    this.registerRule(require('../rules/maximum-number-of-lines'));
    this.registerRule(require('../rules/validate-newline-after-array-elements'));
    this.registerRule(require('../rules/disallow-not-operators-in-conditionals'));
};
/**
 * Registers built-in Code Style cheking presets.
 */
Function (anonymous_193)
✓ Was calledConfiguration.prototype.registerDefaultPresets = function() {···
    // https://github.com/airbnb/javascript
    this.registerPreset('airbnb', require('../../presets/airbnb.json'));

    // http://javascript.crockford.com/code.html
    this.registerPreset('crockford', require('../../presets/crockford.json'));

    // https://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml
    this.registerPreset('google', require('../../presets/google.json'));

    // http://gruntjs.com/contributing#syntax
    this.registerPreset('grunt', require('../../presets/grunt.json'));

    // https://contribute.jquery.org/style-guide/js/
    this.registerPreset('jquery', require('../../presets/jquery.json'));

    // https://github.com/mrdoob/three.js/wiki/Mr.doob's-Code-Style%E2%84%A2
    this.registerPreset('mdcs', require('../../presets/mdcs.json'));

    // https://github.com/felixge/node-style-guide#nodejs-style-guide
    this.registerPreset('node-style-guide', require('../../presets/node-style-guide.json'));

    // https://www.mediawiki.org/wiki/Manual:Coding_conventions/JavaScript
    this.registerPreset('wikimedia', require('../../presets/wikimedia.json'));

    // https://make.wordpress.org/core/handbook/coding-standards/javascript/
    this.registerPreset('wordpress', require('../../presets/wordpress.json'));

    // https://github.com/yandex/codestyle/blob/master/javascript.md
    this.registerPreset('yandex', require('../../presets/yandex.json'));
};
Configuration.prototype.registerDefaultPresets = function() {
    // https://github.com/airbnb/javascript
    this.registerPreset('airbnb', require('../../presets/airbnb.json'));
    // http://javascript.crockford.com/code.html
    this.registerPreset('crockford', require('../../presets/crockford.json'));
    // https://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml
    this.registerPreset('google', require('../../presets/google.json'));
    // http://gruntjs.com/contributing#syntax
    this.registerPreset('grunt', require('../../presets/grunt.json'));
    // https://contribute.jquery.org/style-guide/js/
    this.registerPreset('jquery', require('../../presets/jquery.json'));
    // https://github.com/mrdoob/three.js/wiki/Mr.doob's-Code-Style%E2%84%A2
    this.registerPreset('mdcs', require('../../presets/mdcs.json'));
    // https://github.com/felixge/node-style-guide#nodejs-style-guide
    this.registerPreset('node-style-guide', require('../../presets/node-style-guide.json'));
    // https://www.mediawiki.org/wiki/Manual:Coding_conventions/JavaScript
    this.registerPreset('wikimedia', require('../../presets/wikimedia.json'));
    // https://make.wordpress.org/core/handbook/coding-standards/javascript/
    this.registerPreset('wordpress', require('../../presets/wordpress.json'));
    // https://github.com/yandex/codestyle/blob/master/javascript.md
    this.registerPreset('yandex', require('../../presets/yandex.json'));
};
module.exports = Configuration;
Function copyConfiguration
✓ Was calledfunction copyConfiguration(source, dest) {···
    Object.keys(source).forEach(function(key) {
        dest[key] = source[key];
    });
    if (source.configPath) {
        dest.configPath = source.configPath;
    }
}
function copyConfiguration(source, dest) {
Function (anonymous_195)
✓ Was called    Object.keys(source).forEach(function(key) {···
        dest[key] = source[key];
    });
    Object.keys(source).forEach(function(key) {
        dest[key] = source[key];
    });
Branch IfStatement
✓ Positive was executed (if)    if (source.configPath) {···
        dest.configPath = source.configPath;
    }
✓ Negative was executed (else)    }···
}
    if (source.configPath) {
        dest.configPath = source.configPath;
    }
}

node-configuration.js
var path = require('path');
var util = require('util');
var utils = require('../utils');
var glob = require('glob');
var Configuration = require('./configuration');
var assert = require('assert');
var OVERRIDE_OPTIONS = [
    'preset',
    'maxErrors',
    'errorFilter',
    'esprima',
    'es3',
    'verbose',
    'esnext'
];
/**
 * nodejs-compatible configuration module.
 *
 * @name NodeConfiguration
 * @augments Configuration
 * @constructor
 */
Function NodeConfiguration
✓ Was calledfunction NodeConfiguration() {···
    Configuration.call(this);
    this._basePath = process.cwd();
}
function NodeConfiguration() {
    Configuration.call(this);
    this._basePath = process.cwd();
}
util.inherits(NodeConfiguration, Configuration);
/**
 * Overrides configuration with options specified by the CLI
 *
 * @param {Object} program
 */
Function (anonymous_197)
✓ Was calledNodeConfiguration.prototype.overrideFromCLI = function(program) {···
    var overrides = {};

    OVERRIDE_OPTIONS.forEach(function(option) {
        if (program[option]) {
            overrides[option] = program[option];
        }
    });

    this.override(overrides);
};
NodeConfiguration.prototype.overrideFromCLI = function(program) {
    var overrides = {};
Function (anonymous_198)
✓ Was called    OVERRIDE_OPTIONS.forEach(function(option) {···
        if (program[option]) {
            overrides[option] = program[option];
        }
    });
    OVERRIDE_OPTIONS.forEach(function(option) {
Branch IfStatement
✓ Positive was executed (if)        if (program[option]) {···
            overrides[option] = program[option];
        }
✓ Negative was executed (else)        }···
    });
        if (program[option]) {
            overrides[option] = program[option];
        }
    });
    this.override(overrides);
};
/**
 * Loads plugin data.
 *
 * @param {String|function(Configuration)} plugin
 * @protected
 */
Function (anonymous_199)
✓ Was calledNodeConfiguration.prototype._loadPlugin = function(plugin) {···
    if (typeof plugin === 'string') {
        var pluginPath = utils.normalizePath(plugin, this._basePath);
        plugin = require(pluginPath);
    }
    Configuration.prototype._loadPlugin.call(this, plugin);
};
NodeConfiguration.prototype._loadPlugin = function(plugin) {
Branch IfStatement
✓ Positive was executed (if)    if (typeof plugin === 'string') {···
        var pluginPath = utils.normalizePath(plugin, this._basePath);
        plugin = require(pluginPath);
    }
✓ Negative was executed (else)    }···
    Configuration.prototype._loadPlugin.call(this, plugin);
    if (typeof plugin === 'string') {
        var pluginPath = utils.normalizePath(plugin, this._basePath);
        plugin = require(pluginPath);
    }
    Configuration.prototype._loadPlugin.call(this, plugin);
};
/**
 * Loads an error filter module
 *
 * @param {String|null} errorFilter
 * @protected
 */
Function (anonymous_200)
✓ Was calledNodeConfiguration.prototype._loadErrorFilter = function(errorFilter) {···
    assert(
        typeof errorFilter === 'string' || errorFilter === null,
        '`errorFilter` option requires a string or null value'
    );

    if (errorFilter) {
        errorFilter = utils.normalizePath(errorFilter, this._basePath);
        errorFilter = require(errorFilter);
    }

    Configuration.prototype._loadErrorFilter.call(this, errorFilter);
};
NodeConfiguration.prototype._loadErrorFilter = function(errorFilter) {
    assert(
Branch LogicalExpression
✓ Was returned        typeof errorFilter === 'string' || errorFilter === null,
✓ Was returned        typeof errorFilter === 'string' || errorFilter === null,
        typeof errorFilter === 'string' || errorFilter === null,
        '`errorFilter` option requires a string or null value'
    );
Branch IfStatement
✓ Positive was executed (if)    if (errorFilter) {···
        errorFilter = utils.normalizePath(errorFilter, this._basePath);
        errorFilter = require(errorFilter);
    }
✓ Negative was executed (else)    }···

    Configuration.prototype._loadErrorFilter.call(this, errorFilter);
    if (errorFilter) {
        errorFilter = utils.normalizePath(errorFilter, this._basePath);
        errorFilter = require(errorFilter);
    }
    Configuration.prototype._loadErrorFilter.call(this, errorFilter);
};
/**
 * Loads a custom esprima.
 *
 * @param {String|null} esprima
 * @protected
 */
Function (anonymous_201)
✓ Was calledNodeConfiguration.prototype._loadEsprima = function(esprima) {···
    assert(
        typeof esprima === 'string' || esprima === null,
        '`esprima` option requires a string or null value'
    );

    if (esprima) {
        esprima = utils.normalizePath(esprima, this._basePath);
        esprima = require(esprima);
    }

    Configuration.prototype._loadEsprima.call(this, esprima);
};
NodeConfiguration.prototype._loadEsprima = function(esprima) {
    assert(
Branch LogicalExpression
✗ Was not returned        typeof esprima === 'string' || esprima === null,
✓ Was returned        typeof esprima === 'string' || esprima === null,
        typeof esprima === 'string' || esprima === null,
        '`esprima` option requires a string or null value'
    );
Branch IfStatement
✓ Positive was executed (if)    if (esprima) {···
        esprima = utils.normalizePath(esprima, this._basePath);
        esprima = require(esprima);
    }
✗ Negative was not executed (else)    }···

    Configuration.prototype._loadEsprima.call(this, esprima);
    if (esprima) {
        esprima = utils.normalizePath(esprima, this._basePath);
        esprima = require(esprima);
    }
    Configuration.prototype._loadEsprima.call(this, esprima);
};
/**
 * Loads additional rule.
 *
 * @param {String|Rule} additionalRule
 * @protected
 */
Function (anonymous_202)
✓ Was calledNodeConfiguration.prototype._loadAdditionalRule = function(additionalRule) {···
    if (typeof additionalRule === 'string') {
        glob.sync(path.resolve(this._basePath, additionalRule)).forEach(function(path) {
            var Rule = require(path);
            Configuration.prototype._loadAdditionalRule.call(this, new Rule());
        }, this);
    } else {
        Configuration.prototype._loadAdditionalRule.call(this, additionalRule);
    }
};
NodeConfiguration.prototype._loadAdditionalRule = function(additionalRule) {
Branch IfStatement
✓ Positive was executed (if)    if (typeof additionalRule === 'string') {···
        glob.sync(path.resolve(this._basePath, additionalRule)).forEach(function(path) {
            var Rule = require(path);
            Configuration.prototype._loadAdditionalRule.call(this, new Rule());
        }, this);
    } else {
✓ Negative was executed (else)    } else {···
        Configuration.prototype._loadAdditionalRule.call(this, additionalRule);
    }
    if (typeof additionalRule === 'string') {
Function (anonymous_203)
✓ Was called        glob.sync(path.resolve(this._basePath, additionalRule)).forEach(function(path) {···
            var Rule = require(path);
            Configuration.prototype._loadAdditionalRule.call(this, new Rule());
        }, this);
        glob.sync(path.resolve(this._basePath, additionalRule)).forEach(function(path) {
            var Rule = require(path);
            Configuration.prototype._loadAdditionalRule.call(this, new Rule());
        }, this);
    } else {
        Configuration.prototype._loadAdditionalRule.call(this, additionalRule);
    }
};
module.exports = NodeConfiguration;

utils.js
var path = require('path');
var Vow = require('vow');
// 7.5.2, 7.6.1 Reserved words
var ES3_KEYWORDS = {
    'break': true,
    'case': true,
    'catch': true,
    'continue': true,
    'default': true,
    'delete': true,
    'do': true,
    'else': true,
    'false': true,
    'finally': true,
    'for': true,
    'function': true,
    'if': true,
    'in': true,
    'instanceof': true,
    'new': true,
    'null': true,
    'return': true,
    'switch': true,
    'this': true,
    'throw': true,
    'true': true,
    'try': true,
    'typeof': true,
    'var': true,
    'void': true,
    'while': true,
    'with': true
};
// 7.5.3 Future Reserved Words
var ES3_FUTURE_RESERVED_WORDS = {
    'abstract': true,
    'boolean': true,
    'byte': true,
    'char': true,
    'class': true,
    'const': true,
    'debugger': true,
    'double': true,
    'enum': true,
    'export': true,
    'extends': true,
    'final': true,
    'float': true,
    'goto': true,
    'implements': true,
    'import': true,
    'int': true,
    'interface': true,
    'long': true,
    'native': true,
    'package': true,
    'private': true,
    'protected': true,
    'public': true,
    'short': true,
    'static': true,
    'super': true,
    'synchronized': true,
    'throws': true,
    'transient': true,
    'volatile': true
};
var IDENTIFIER_NAME_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
var TRAILING_UNDERSCORES_RE = /(^_+|_+$)/g;
var SNAKE_CASE_RE = /^([a-z$][a-z0-9$]+)(_[a-z0-9$]+)+$/i;
/**
 * All keywords where spaces are a stylistic choice
 * @type {Array}
 */
exports.spacedKeywords = [
    'do',
    'for',
    'if',
    'else',
    'switch',
    'case',
    'try',
    'catch',
    'finally',
    'void',
    'while',
    'with',
    'return',
    'typeof',
    'function'
];
/**
 * All keywords where curly braces are a stylistic choice
 * @type {Array}
 */
exports.curlyBracedKeywords = [
    'if',
    'else',
    'for',
    'while',
    'do',
    'case',
    'default',
    'with'
];
/**
 * Returns true if word is keyword in ECMAScript 3 specification.
 *
 * @param {String} word
 * @returns {Boolean}
 */
Function (anonymous_204)
✓ Was calledexports.isEs3Keyword = function(word) {···
    return Boolean(ES3_KEYWORDS[word]);
};
exports.isEs3Keyword = function(word) {
    return Boolean(ES3_KEYWORDS[word]);
};
/**
 * Returns true if word is future reserved word in ECMAScript 3 specification.
 *
 * @param {String} word
 * @returns {Boolean}
 */
Function (anonymous_205)
✓ Was calledexports.isEs3FutureReservedWord = function(word) {···
    return Boolean(ES3_FUTURE_RESERVED_WORDS[word]);
};
exports.isEs3FutureReservedWord = function(word) {
    return Boolean(ES3_FUTURE_RESERVED_WORDS[word]);
};
/**
 * Returns true if name is valid identifier name.
 *
 * @param {String} name
 * @returns {Boolean}
 */
Function (anonymous_206)
✓ Was calledexports.isValidIdentifierName = function(name) {···
    return IDENTIFIER_NAME_RE.test(name);
};
exports.isValidIdentifierName = function(name) {
    return IDENTIFIER_NAME_RE.test(name);
};
/**
 * Snake case tester
 *
 * @param {String} name
 * @return {Boolean}
 */
Function (anonymous_207)
✓ Was calledexports.isSnakeCased = function(name) {···
    return SNAKE_CASE_RE.test(name);
};
exports.isSnakeCased = function(name) {
    return SNAKE_CASE_RE.test(name);
};
/**
 * Returns the function expression node if the provided node is an iffe,
 * other returns undefined.
 *
 * @param  {Object} node
 * @return {?Object}
 */
Function (anonymous_208)
✓ Was calledexports.getFunctionNodeFromIIFE = function(node) {···
    if (node.type !== 'CallExpression') {
        return null;
    }

    var callee = node.callee;

    if (callee.type === 'FunctionExpression') {
        return callee;
    }

    if (callee.type === 'MemberExpression' &&
        callee.object.type === 'FunctionExpression' &&
        callee.property.type === 'Identifier' &&
        (callee.property.name === 'call' || callee.property.name === 'apply')
    ) {
        return callee.object;
    }

    return null;
};
exports.getFunctionNodeFromIIFE = function(node) {
Branch IfStatement
✓ Positive was executed (if)    if (node.type !== 'CallExpression') {···
        return null;
    }
✓ Negative was executed (else)    }···

    var callee = node.callee;
    if (node.type !== 'CallExpression') {
        return null;
    }
    var callee = node.callee;
Branch IfStatement
✓ Positive was executed (if)    if (callee.type === 'FunctionExpression') {···
        return callee;
    }
✓ Negative was executed (else)    }···

    if (callee.type === 'MemberExpression' &&
    if (callee.type === 'FunctionExpression') {
        return callee;
    }
Branch IfStatement
✓ Positive was executed (if)    ) {···
        return callee.object;
    }
✓ Negative was executed (else)    }···

    return null;
Branch LogicalExpression
✓ Was returned        (callee.property.name === 'call' || callee.property.name === 'apply')
✓ Was returned    if (callee.type === 'MemberExpression' &&···
        callee.object.type === 'FunctionExpression' &&
        callee.property.type === 'Identifier' &&
Branch LogicalExpression
✓ Was returned        callee.property.type === 'Identifier' &&
✓ Was returned    if (callee.type === 'MemberExpression' &&···
        callee.object.type === 'FunctionExpression' &&
Branch LogicalExpression
✓ Was returned        callee.object.type === 'FunctionExpression' &&
✓ Was returned    if (callee.type === 'MemberExpression' &&
    if (callee.type === 'MemberExpression' &&
        callee.object.type === 'FunctionExpression' &&
        callee.property.type === 'Identifier' &&
Branch LogicalExpression
✓ Was returned        (callee.property.name === 'call' || callee.property.name === 'apply')
✓ Was returned        (callee.property.name === 'call' || callee.property.name === 'apply')
        (callee.property.name === 'call' || callee.property.name === 'apply')
    ) {
        return callee.object;
    }
    return null;
};
/**
 * Trims leading and trailing underscores
 *
 * @param {String} name
 * @return {String}
 */
Function (anonymous_209)
✓ Was calledexports.trimUnderscores = function(name) {···
    var res = name.replace(TRAILING_UNDERSCORES_RE, '');
    return res ? res : name;
};
exports.trimUnderscores = function(name) {
    var res = name.replace(TRAILING_UNDERSCORES_RE, '');
Branch ConditionalExpression
✓ Positive was returned (? ...)    return res ? res : name;
✓ Negative was returned (: ...)    return res ? res : name;
    return res ? res : name;
};
/**
 * Whether or not the given path is relative
 * @param  {String}  path
 * @return {Boolean}
 */
Function (anonymous_210)
✓ Was calledexports.isRelativePath = function(path) {···
    // Logic from: https://github.com/joyent/node/blob/4f1ae11a62b97052bc83756f8cb8700cc1f61661/lib/module.js#L237
    var start = path.substring(0, 2);
    return start === './' || start === '..';
};
exports.isRelativePath = function(path) {
    // Logic from: https://github.com/joyent/node/blob/4f1ae11a62b97052bc83756f8cb8700cc1f61661/lib/module.js#L237
    var start = path.substring(0, 2);
Branch LogicalExpression
✓ Was returned    return start === './' || start === '..';
✓ Was returned    return start === './' || start === '..';
    return start === './' || start === '..';
};
/**
 * Resolves a relative filepath against the supplied base path
 * or just returns the filepath if not relative
 *
 * @param  {String} filepath
 * @param  {String} basePath
 * @return {String}
 */
Function (anonymous_211)
✓ Was calledexports.normalizePath = function(filepath, basePath) {···
    if (this.isRelativePath(filepath)) {
        return path.resolve(basePath, filepath);
    }

    return filepath;
};
exports.normalizePath = function(filepath, basePath) {
Branch IfStatement
✓ Positive was executed (if)    if (this.isRelativePath(filepath)) {···
        return path.resolve(basePath, filepath);
    }
✓ Negative was executed (else)    }···

    return filepath;
    if (this.isRelativePath(filepath)) {
        return path.resolve(basePath, filepath);
    }
    return filepath;
};
/**
 * Wraps a function such that you can interact with a promise and not a
 * node-style callback.
 *
 * @param  {Function} fn - function that expects a node-style callback
 * @return {Function} When invoked with arguments, returns a promise resolved/rejected
 *                    based on the results of the wrapped node-style callback
 */
Function (anonymous_212)
✓ Was calledexports.promisify = function(fn) {···
    return function() {
        var deferred = Vow.defer();
        var args = [].slice.call(arguments);

        args.push(function(err, result) {
            if (err) {
                deferred.reject(err);
            } else {
                deferred.resolve(result);
            }
        });

        fn.apply(null, args);

        return deferred.promise();
    };
};
exports.promisify = function(fn) {
Function (anonymous_213)
✓ Was called    return function() {···
        var deferred = Vow.defer();
        var args = [].slice.call(arguments);

        args.push(function(err, result) {
            if (err) {
                deferred.reject(err);
            } else {
                deferred.resolve(result);
            }
        });

        fn.apply(null, args);

        return deferred.promise();
    };
    return function() {
        var deferred = Vow.defer();
        var args = [].slice.call(arguments);
Function (anonymous_214)
✓ Was called        args.push(function(err, result) {···
            if (err) {
                deferred.reject(err);
            } else {
                deferred.resolve(result);
            }
        });
        args.push(function(err, result) {
Branch IfStatement
✓ Positive was executed (if)            if (err) {···
                deferred.reject(err);
            } else {
✓ Negative was executed (else)            } else {···
                deferred.resolve(result);
            }
            if (err) {
                deferred.reject(err);
            } else {
                deferred.resolve(result);
            }
        });
        fn.apply(null, args);
        return deferred.promise();
    };
};
/**
 * All possible binary operators supported by JSCS
 * @type {Array}
 */
exports.binaryOperators = [
    // assignment operators
    '=', '+=', '-=', '*=', '/=', '%=', '<<=', '>>=', '>>>=',
    '&=', '|=', '^=',
    '+', '-', '*', '/', '%', '<<', '>>', '>>>', '&',
    '|', '^', '&&', '||', '===', '==', '>=',
    '<=', '<', '>', '!=', '!==',
    ','
];
/**
 * Increment and decrement operators
 * @type {Array}
 */
exports.incrementAndDecrementOperators = ['++', '--'];
/**
 * All possible unary operators supported by JSCS
 * @type {Array}
 */
exports.unaryOperators = ['-', '+', '!', '~'].concat(exports.incrementAndDecrementOperators);
/**
 * All possible operators support by JSCS
 * @type {Array}
 */
exports.operators = exports.binaryOperators.concat(exports.unaryOperators);

cli-config.js
/**
 * Command line config helpers
 */
var fs = require('fs');
var path = require('path');
var stripJSONComments = require('strip-json-comments');
var supportsColor = require('chalk').supportsColor;
var glob = require('glob');
// Configuration sources in priority order.
var configs = ['package.json', '.jscsrc', '.jscs.json'];
// Before, "findup-sync" package was used,
// but it does not provide filter callback
Function findup
✓ Was calledfunction findup(patterns, options, fn) {···
    /* jshint -W083 */

    var lastpath;
    var file;

    options = Object.create(options);
    options.maxDepth = 1;
    options.cwd = path.resolve(options.cwd);

    do {
        file = patterns.filter(function(pattern) {
            var configPath = glob.sync(pattern, options)[0];

            if (configPath) {
                return fn(path.join(options.cwd, configPath));
            }
        })[0];

        if (file) {
            return path.join(options.cwd, file);
        }

        lastpath = options.cwd;
        options.cwd = path.resolve(options.cwd, '..');
    } while (options.cwd !== lastpath);
}
function findup(patterns, options, fn) {
    /* jshint -W083 */
    var lastpath;
    var file;
    options = Object.create(options);
    options.maxDepth = 1;
    options.cwd = path.resolve(options.cwd);
    do {
Function (anonymous_216)
✓ Was called        file = patterns.filter(function(pattern) {···
            var configPath = glob.sync(pattern, options)[0];

            if (configPath) {
                return fn(path.join(options.cwd, configPath));
            }
        })[0];
        file = patterns.filter(function(pattern) {
            var configPath = glob.sync(pattern, options)[0];
Branch IfStatement
✓ Positive was executed (if)            if (configPath) {···
                return fn(path.join(options.cwd, configPath));
            }
✓ Negative was executed (else)            }···
        })[0];
            if (configPath) {
                return fn(path.join(options.cwd, configPath));
            }
        })[0];
Branch IfStatement
✓ Positive was executed (if)        if (file) {···
            return path.join(options.cwd, file);
        }
✓ Negative was executed (else)        }···

        lastpath = options.cwd;
        if (file) {
            return path.join(options.cwd, file);
        }
        lastpath = options.cwd;
        options.cwd = path.resolve(options.cwd, '..');
    } while (options.cwd !== lastpath);
}
/**
 * Get content of the configuration file
 * @param {String} config - partial path to configuration file
 * @param {String} directory - directory path which will be joined with config argument
 * @return {Object}
 */
Function (anonymous_217)
✓ Was calledexports.getContent = function(config, directory) {···
    if (!config) {
        return;
    }

    var configPath = path.resolve(directory, config);
    var ext;
    var content;

    config = path.basename(config);

    if (fs.existsSync(configPath)) {
        ext = path.extname(configPath);

        if (ext === '.js' || ext === '.json') {
            content = require(configPath);
        } else {
            content = JSON.parse(
                stripJSONComments(
                    fs.readFileSync(configPath, 'utf8')
                )
            );
        }

        // Adding property via Object.defineProperty makes it
        // non-enumerable and avoids warning for unsupported rules
        Object.defineProperty(content, 'configPath', {
            value: configPath
        });
    }

    return content && config === 'package.json' ? content.jscsConfig : content;
};
exports.getContent = function(config, directory) {
Branch IfStatement
✓ Positive was executed (if)    if (!config) {···
        return;
    }
✓ Negative was executed (else)    }···

    var configPath = path.resolve(directory, config);
    if (!config) {
        return;
    }
    var configPath = path.resolve(directory, config);
    var ext;
    var content;
    config = path.basename(config);
Branch IfStatement
✓ Positive was executed (if)    if (fs.existsSync(configPath)) {···
        ext = path.extname(configPath);

        if (ext === '.js' || ext === '.json') {
            content = require(configPath);
        } else {
            content = JSON.parse(
                stripJSONComments(
                    fs.readFileSync(configPath, 'utf8')
                )
            );
        }

        // Adding property via Object.defineProperty makes it
        // non-enumerable and avoids warning for unsupported rules
        Object.defineProperty(content, 'configPath', {
            value: configPath
        });
    }
✓ Negative was executed (else)    }···

    return content && config === 'package.json' ? content.jscsConfig : content;
    if (fs.existsSync(configPath)) {
        ext = path.extname(configPath);
Branch IfStatement
✓ Positive was executed (if)        if (ext === '.js' || ext === '.json') {···
            content = require(configPath);
        } else {
✓ Negative was executed (else)        } else {···
            content = JSON.parse(
                stripJSONComments(
                    fs.readFileSync(configPath, 'utf8')
                )
            );
        }
Branch LogicalExpression
✓ Was returned        if (ext === '.js' || ext === '.json') {
✓ Was returned        if (ext === '.js' || ext === '.json') {
        if (ext === '.js' || ext === '.json') {
            content = require(configPath);
        } else {
            content = JSON.parse(
                stripJSONComments(
                    fs.readFileSync(configPath, 'utf8')
                )
            );
        }
        // Adding property via Object.defineProperty makes it
        // non-enumerable and avoids warning for unsupported rules
        Object.defineProperty(content, 'configPath', {
            value: configPath
        });
    }
Branch ConditionalExpression
✓ Positive was returned (? ...)    return content && config === 'package.json' ? content.jscsConfig : content;
✓ Negative was returned (: ...)    return content && config === 'package.json' ? content.jscsConfig : content;
Branch LogicalExpression
✓ Was returned    return content && config === 'package.json' ? content.jscsConfig : content;
✓ Was returned    return content && config === 'package.json' ? content.jscsConfig : content;
    return content && config === 'package.json' ? content.jscsConfig : content;
};
/**
 * Get content of the configuration file
 * @param {String} config - partial path to configuration file
 * @param {String} [cwd = process.cwd()] - directory path which will be joined with config argument
 * @return {Object|undefined}
 */
Function (anonymous_218)
✓ Was calledexports.load = function(config, cwd) {···
    var content;
    var directory = cwd || process.cwd();

    // If config option is given, attempt to load it
    if (config) {
        return this.getContent(config, directory);
    }

    content = this.getContent(
        findup(configs, { nocase: true, cwd: directory }, function(configPath) {
            if (path.basename(configPath) === 'package.json') {
                return !!this.getContent(configPath);
            }

            return true;
        }.bind(this))
    );

    if (content) {
        return content;
    }

    // Try to load standard configs from home dir
    var directoryArr = [process.env.USERPROFILE, process.env.HOMEPATH, process.env.HOME];
    for (var i = 0, dirLen = directoryArr.length; i < dirLen; i++) {
        if (!directoryArr[i]) {
            continue;
        }

        for (var j = 0, len = configs.length; j < len; j++) {
            content = this.getContent(configs[j], directoryArr[i]);

            if (content) {
                return content;
            }
        }
    }
};
exports.load = function(config, cwd) {
    var content;
Branch LogicalExpression
✓ Was returned    var directory = cwd || process.cwd();
✓ Was returned    var directory = cwd || process.cwd();
    var directory = cwd || process.cwd();
    // If config option is given, attempt to load it
Branch IfStatement
✓ Positive was executed (if)    if (config) {···
        return this.getContent(config, directory);
    }
✓ Negative was executed (else)    }···

    content = this.getContent(
    if (config) {
        return this.getContent(config, directory);
    }
    content = this.getContent(
Function (anonymous_219)
✓ Was called        findup(configs, { nocase: true, cwd: directory }, function(configPath) {···
            if (path.basename(configPath) === 'package.json') {
                return !!this.getContent(configPath);
            }

            return true;
        }.bind(this))
        findup(configs, { nocase: true, cwd: directory }, function(configPath) {
Branch IfStatement
✓ Positive was executed (if)            if (path.basename(configPath) === 'package.json') {···
                return !!this.getContent(configPath);
            }
✓ Negative was executed (else)            }···

            return true;
            if (path.basename(configPath) === 'package.json') {
                return !!this.getContent(configPath);
            }
            return true;
        }.bind(this))
    );
Branch IfStatement
✓ Positive was executed (if)    if (content) {···
        return content;
    }
✓ Negative was executed (else)    }···

    // Try to load standard configs from home dir
    if (content) {
        return content;
    }
    // Try to load standard configs from home dir
    var directoryArr = [process.env.USERPROFILE, process.env.HOMEPATH, process.env.HOME];
    for (var i = 0, dirLen = directoryArr.length; i < dirLen; i++) {
Branch IfStatement
✓ Positive was executed (if)        if (!directoryArr[i]) {···
            continue;
        }
✓ Negative was executed (else)        }···

        for (var j = 0, len = configs.length; j < len; j++) {
        if (!directoryArr[i]) {
            continue;
        }
        for (var j = 0, len = configs.length; j < len; j++) {
            content = this.getContent(configs[j], directoryArr[i]);
Branch IfStatement
✓ Positive was executed (if)            if (content) {···
                return content;
            }
✓ Negative was executed (else)            }···
        }
            if (content) {
                return content;
            }
        }
    }
};
/**
 * Get reporter function and path to it
 * @param {String} reporter - path or the name of one of the pre-defined reporters
 * @param {Boolean} [colors = true] - should it be a colorful output?
 * @return {{writer: Function, path: String}}
 */
Function (anonymous_220)
✓ Was calledexports.getReporter = function(reporter, colors) {···
    var writerPath;
    var writer;

    if (colors !== false) {
        colors = true;
    }

    if (reporter) {
        // ensure reporter is a string (and allow non-string types to be coerced)
        reporter = reporter.toString();
        writerPath = path.resolve(process.cwd(), reporter);

        if (!fs.existsSync(writerPath)) {
            writerPath = path.resolve(__dirname, './reporters/' + reporter);
        }
    } else {
        writerPath = path.resolve(
            __dirname, './reporters/', (colors && supportsColor ? 'console' : 'text')
        );
    }

    try {
        writer = require(writerPath);
    } catch (e) {
        writer = null;
    }

    return {
        path: writerPath,
        writer: writer
    };
};
exports.getReporter = function(reporter, colors) {
    var writerPath;
    var writer;
Branch IfStatement
✓ Positive was executed (if)    if (colors !== false) {···
        colors = true;
    }
✓ Negative was executed (else)    }···

    if (reporter) {
    if (colors !== false) {
        colors = true;
    }
Branch IfStatement
✓ Positive was executed (if)    if (reporter) {···
        // ensure reporter is a string (and allow non-string types to be coerced)
        reporter = reporter.toString();
        writerPath = path.resolve(process.cwd(), reporter);

        if (!fs.existsSync(writerPath)) {
            writerPath = path.resolve(__dirname, './reporters/' + reporter);
        }
    } else {
✓ Negative was executed (else)    } else {···
        writerPath = path.resolve(
            __dirname, './reporters/', (colors && supportsColor ? 'console' : 'text')
        );
    }
    if (reporter) {
        // ensure reporter is a string (and allow non-string types to be coerced)
        reporter = reporter.toString();
        writerPath = path.resolve(process.cwd(), reporter);
Branch IfStatement
✓ Positive was executed (if)        if (!fs.existsSync(writerPath)) {···
            writerPath = path.resolve(__dirname, './reporters/' + reporter);
        }
✓ Negative was executed (else)        }···
    } else {
        if (!fs.existsSync(writerPath)) {
            writerPath = path.resolve(__dirname, './reporters/' + reporter);
        }
    } else {
        writerPath = path.resolve(
Branch ConditionalExpression
✓ Positive was returned (? ...)            __dirname, './reporters/', (colors && supportsColor ? 'console' : 'text')
✓ Negative was returned (: ...)            __dirname, './reporters/', (colors && supportsColor ? 'console' : 'text')
Branch LogicalExpression
✓ Was returned            __dirname, './reporters/', (colors && supportsColor ? 'console' : 'text')
✓ Was returned            __dirname, './reporters/', (colors && supportsColor ? 'console' : 'text')
            __dirname, './reporters/', (colors && supportsColor ? 'console' : 'text')
        );
    }
    try {
        writer = require(writerPath);
    } catch (e) {
        writer = null;
    }
    return {
        path: writerPath,
        writer: writer
    };
};

cli.js
/**
 * Command line implementation for JSCS.
 *
 * Common usage case is:
 *
 * ./node_modules/.bin/jscs file1 dir1 file2 dir2
 */
var Checker = require('./checker');
var configFile = require('./cli-config');
var ConfigGenerator = require('./config/generator');
var Vow = require('vow');
var exit = require('exit');
Function (anonymous_221)
✓ Was calledmodule.exports = function(program) {···
    var reporter;
    var config;
    var checkerPromise;
    var defer = Vow.defer();
    var promise = defer.promise();
    var checker = new Checker();
    var args = program.args;
    var returnArgs = {
        checker: checker,
        reporter: program.reporter,
        promise: promise
    };

    promise.always(function(status) {
        exit(status.valueOf());
    });

    try {
        config = configFile.load(program.config);
    } catch (e) {
        console.error('Config source is corrupted -', e.toString());
        defer.reject(1);

        return returnArgs;
    }

    /**
     * Trying to load config.
     * Custom config path can be specified using '-c' option.
     */
    if (!config && !program.preset && !program.autoConfigure) {
        if (program.config) {
            console.error('Configuration source', program.config, 'was not found.');
        } else {
            console.error('No configuration found. Add a .jscsrc file to your project root or use the -c option.');
        }

        defer.reject(1);

        return returnArgs;
    }

    if (!args.length && process.stdin.isTTY && typeof program.autoConfigure !== 'string') {
        console.error('No input files specified. Try option --help for usage information.');
        defer.reject(1);

        return returnArgs;
    }

    reporter = configFile.getReporter(program.reporter, program.colors);

    returnArgs.reporter = reporter.path;

    if (!reporter.writer) {
        console.error('Reporter "%s" doesn\'t exist.', reporter.writer);
        returnArgs.reporter = reporter.path;
        defer.reject(1);

        return returnArgs;
    }

    if (!config) {
        config = {};
    }

    checker.getConfiguration().overrideFromCLI(program);
    checker.getConfiguration().registerDefaultRules();

    try {
        checker.configure(config);
    } catch (e) {
        console.error(e.message);
        defer.reject(1);

        return returnArgs;
    }
    if (program.autoConfigure) {
        var generator = new ConfigGenerator();

        generator
        .generate(program.autoConfigure)
        .then(function() {
            defer.resolve(0);
        }, function(error) {
            console.error('Configuration generation failed due to ', error);
            defer.reject(1);
        });

        return returnArgs;
    }

    // Handle usage like 'cat myfile.js | jscs' or 'jscs -''
    var usedDash = args[args.length - 1] === '-';
    if (!args.length || usedDash) {
        // So the dash doesn't register as a file
        if (usedDash) { args.length--; }

        if (program.fix) {
            return {
                promise: checker.fixStdin().then(function(result) {
                    process.stdout.write(result.output);
                }),
                checker: checker
            };
        }

        checkerPromise = checker.checkStdin().then(function(errors) {
            return [errors];
        });
    }

    // Processing specified files and dirs.
    if (args.length) {
        var method = program.fix ? checker.fixPath : checker.checkPath;
        checkerPromise = Vow.all(args.map(method, checker)).then(function(results) {
            return [].concat.apply([], results);
        });
    }

    checkerPromise.then(function(errorsCollection) {
        reporter.writer(errorsCollection);
        handleMaxErrors();

        errorsCollection.forEach(function(errors) {
            if (!errors.isEmpty()) {
                defer.reject(2);
            }
        });

        defer.resolve(0);
    }).fail(function(e) {
        console.error(e.stack);
        defer.reject(1);
    });

    return returnArgs;

    function handleMaxErrors() {
        if (checker.maxErrorsExceeded()) {
            console.log('Too many errors... Increase `maxErrors` configuration option value to see more.');
        }
    }
};
module.exports = function(program) {
    var reporter;
    var config;
    var checkerPromise;
    var defer = Vow.defer();
    var promise = defer.promise();
    var checker = new Checker();
    var args = program.args;
    var returnArgs = {
        checker: checker,
        reporter: program.reporter,
        promise: promise
    };
Function (anonymous_222)
✓ Was called    promise.always(function(status) {···
        exit(status.valueOf());
    });
    promise.always(function(status) {
        exit(status.valueOf());
    });
    try {
        config = configFile.load(program.config);
    } catch (e) {
        console.error('Config source is corrupted -', e.toString());
        defer.reject(1);
        return returnArgs;
    }
    /**
     * Trying to load config.
     * Custom config path can be specified using '-c' option.
     */
Branch IfStatement
✓ Positive was executed (if)    if (!config && !program.preset && !program.autoConfigure) {···
        if (program.config) {
            console.error('Configuration source', program.config, 'was not found.');
        } else {
            console.error('No configuration found. Add a .jscsrc file to your project root or use the -c option.');
        }

        defer.reject(1);

        return returnArgs;
    }
✓ Negative was executed (else)    }···

    if (!args.length && process.stdin.isTTY && typeof program.autoConfigure !== 'string') {
Branch LogicalExpression
✓ Was returned    if (!config && !program.preset && !program.autoConfigure) {
✓ Was returned    if (!config && !program.preset && !program.autoConfigure) {
Branch LogicalExpression
✓ Was returned    if (!config && !program.preset && !program.autoConfigure) {
✓ Was returned    if (!config && !program.preset && !program.autoConfigure) {
    if (!config && !program.preset && !program.autoConfigure) {
Branch IfStatement
✓ Positive was executed (if)        if (program.config) {···
            console.error('Configuration source', program.config, 'was not found.');
        } else {
✓ Negative was executed (else)        } else {···
            console.error('No configuration found. Add a .jscsrc file to your project root or use the -c option.');
        }
        if (program.config) {
            console.error('Configuration source', program.config, 'was not found.');
        } else {
            console.error('No configuration found. Add a .jscsrc file to your project root or use the -c option.');
        }
        defer.reject(1);
        return returnArgs;
    }
Branch IfStatement
✓ Positive was executed (if)    if (!args.length && process.stdin.isTTY && typeof program.autoConfigure !== 'string') {···
        console.error('No input files specified. Try option --help for usage information.');
        defer.reject(1);

        return returnArgs;
    }
✓ Negative was executed (else)    }···

    reporter = configFile.getReporter(program.reporter, program.colors);
Branch LogicalExpression
✓ Was returned    if (!args.length && process.stdin.isTTY && typeof program.autoConfigure !== 'string') {
✓ Was returned    if (!args.length && process.stdin.isTTY && typeof program.autoConfigure !== 'string') {
Branch LogicalExpression
✓ Was returned    if (!args.length && process.stdin.isTTY && typeof program.autoConfigure !== 'string') {
✓ Was returned    if (!args.length && process.stdin.isTTY && typeof program.autoConfigure !== 'string') {
    if (!args.length && process.stdin.isTTY && typeof program.autoConfigure !== 'string') {
        console.error('No input files specified. Try option --help for usage information.');
        defer.reject(1);
        return returnArgs;
    }
    reporter = configFile.getReporter(program.reporter, program.colors);
    returnArgs.reporter = reporter.path;
Branch IfStatement
✓ Positive was executed (if)    if (!reporter.writer) {···
        console.error('Reporter "%s" doesn\'t exist.', reporter.writer);
        returnArgs.reporter = reporter.path;
        defer.reject(1);

        return returnArgs;
    }
✓ Negative was executed (else)    }···

    if (!config) {
    if (!reporter.writer) {
        console.error('Reporter "%s" doesn\'t exist.', reporter.writer);
        returnArgs.reporter = reporter.path;
        defer.reject(1);
        return returnArgs;
    }
Branch IfStatement
✓ Positive was executed (if)    if (!config) {···
        config = {};
    }
✓ Negative was executed (else)    }···

    checker.getConfiguration().overrideFromCLI(program);
    if (!config) {
        config = {};
    }
    checker.getConfiguration().overrideFromCLI(program);
    checker.getConfiguration().registerDefaultRules();
    try {
        checker.configure(config);
    } catch (e) {
        console.error(e.message);
        defer.reject(1);
        return returnArgs;
    }
Branch IfStatement
✓ Positive was executed (if)    if (program.autoConfigure) {···
        var generator = new ConfigGenerator();

        generator
        .generate(program.autoConfigure)
        .then(function() {
            defer.resolve(0);
        }, function(error) {
            console.error('Configuration generation failed due to ', error);
            defer.reject(1);
        });

        return returnArgs;
    }
✓ Negative was executed (else)    }···

    // Handle usage like 'cat myfile.js | jscs' or 'jscs -''
    if (program.autoConfigure) {
        var generator = new ConfigGenerator();
        generator
        .generate(program.autoConfigure)
Function (anonymous_223)
✓ Was called        .then(function() {···
            defer.resolve(0);
        }, function(error) {
        .then(function() {
            defer.resolve(0);
Function (anonymous_224)
✓ Was called        }, function(error) {···
            console.error('Configuration generation failed due to ', error);
            defer.reject(1);
        });
        }, function(error) {
            console.error('Configuration generation failed due to ', error);
            defer.reject(1);
        });
        return returnArgs;
    }
    // Handle usage like 'cat myfile.js | jscs' or 'jscs -''
    var usedDash = args[args.length - 1] === '-';
Branch IfStatement
✓ Positive was executed (if)    if (!args.length || usedDash) {···
        // So the dash doesn't register as a file
        if (usedDash) { args.length--; }

        if (program.fix) {
            return {
                promise: checker.fixStdin().then(function(result) {
                    process.stdout.write(result.output);
                }),
                checker: checker
            };
        }

        checkerPromise = checker.checkStdin().then(function(errors) {
            return [errors];
        });
    }
✓ Negative was executed (else)    }···

    // Processing specified files and dirs.
Branch LogicalExpression
✓ Was returned    if (!args.length || usedDash) {
✓ Was returned    if (!args.length || usedDash) {
    if (!args.length || usedDash) {
        // So the dash doesn't register as a file
Branch IfStatement
✓ Positive was executed (if)        if (usedDash) { args.length--; }
✓ Negative was executed (else)        if (usedDash) { args.length--; }···

        if (program.fix) {
        if (usedDash) { args.length--; }
Branch IfStatement
✗ Positive was not executed (if)        if (program.fix) {···
            return {
                promise: checker.fixStdin().then(function(result) {
                    process.stdout.write(result.output);
                }),
                checker: checker
            };
        }
✓ Negative was executed (else)        }···

        checkerPromise = checker.checkStdin().then(function(errors) {
        if (program.fix) {
            return {
Function (anonymous_225)
✗ Was not called                promise: checker.fixStdin().then(function(result) {···
                    process.stdout.write(result.output);
                }),
                promise: checker.fixStdin().then(function(result) {
                    process.stdout.write(result.output);
                }),
                checker: checker
            };
        }
Function (anonymous_226)
✓ Was called        checkerPromise = checker.checkStdin().then(function(errors) {···
            return [errors];
        });
        checkerPromise = checker.checkStdin().then(function(errors) {
            return [errors];
        });
    }
    // Processing specified files and dirs.
Branch IfStatement
✓ Positive was executed (if)    if (args.length) {···
        var method = program.fix ? checker.fixPath : checker.checkPath;
        checkerPromise = Vow.all(args.map(method, checker)).then(function(results) {
            return [].concat.apply([], results);
        });
    }
✓ Negative was executed (else)    }···

    checkerPromise.then(function(errorsCollection) {
    if (args.length) {
Branch ConditionalExpression
✗ Positive was not returned (? ...)        var method = program.fix ? checker.fixPath : checker.checkPath;
✓ Negative was returned (: ...)        var method = program.fix ? checker.fixPath : checker.checkPath;
        var method = program.fix ? checker.fixPath : checker.checkPath;
Function (anonymous_227)
✓ Was called        checkerPromise = Vow.all(args.map(method, checker)).then(function(results) {···
            return [].concat.apply([], results);
        });
        checkerPromise = Vow.all(args.map(method, checker)).then(function(results) {
            return [].concat.apply([], results);
        });
    }
Function (anonymous_228)
✓ Was called    checkerPromise.then(function(errorsCollection) {···
        reporter.writer(errorsCollection);
        handleMaxErrors();

        errorsCollection.forEach(function(errors) {
            if (!errors.isEmpty()) {
                defer.reject(2);
            }
        });

        defer.resolve(0);
    }).fail(function(e) {
    checkerPromise.then(function(errorsCollection) {
        reporter.writer(errorsCollection);
        handleMaxErrors();
Function (anonymous_229)
✓ Was called        errorsCollection.forEach(function(errors) {···
            if (!errors.isEmpty()) {
                defer.reject(2);
            }
        });
        errorsCollection.forEach(function(errors) {
Branch IfStatement
✓ Positive was executed (if)            if (!errors.isEmpty()) {···
                defer.reject(2);
            }
✓ Negative was executed (else)            }···
        });
            if (!errors.isEmpty()) {
                defer.reject(2);
            }
        });
        defer.resolve(0);
Function (anonymous_230)
✓ Was called    }).fail(function(e) {···
        console.error(e.stack);
        defer.reject(1);
    });
    }).fail(function(e) {
        console.error(e.stack);
        defer.reject(1);
    });
    return returnArgs;
Function handleMaxErrors
✓ Was called    function handleMaxErrors() {···
        if (checker.maxErrorsExceeded()) {
            console.log('Too many errors... Increase `maxErrors` configuration option value to see more.');
        }
    }
    function handleMaxErrors() {
Branch IfStatement
✓ Positive was executed (if)        if (checker.maxErrorsExceeded()) {···
            console.log('Too many errors... Increase `maxErrors` configuration option value to see more.');
        }
✓ Negative was executed (else)        }···
    }
        if (checker.maxErrorsExceeded()) {
            console.log('Too many errors... Increase `maxErrors` configuration option value to see more.');
        }
    }
};

generator.js
var fs = require('fs');
var Vow = require('vow');
var Table = require('cli-table');
var prompt = require('prompt');
var chalk = require('chalk');
var assign = require('lodash.assign');
var Checker = require('../checker');
var utils = require('../utils');
prompt.message = '';
prompt.delimiter = '';
prompt.start();
/**
 * Script that walks the user through the autoconfig flow
 *
 * @type {String[]}
 * @private
 */
var prompts = [
    {
        name: chalk.green('Please choose a preset number:'),
        require: true,
        pattern: /\d+/
    },
    {
        name: 'Create an (e)xception for this rule, or (f)ix the errors yourself?',
        require: true,
        pattern: /(e|f)/
    }
];
/**
 * JSCS Configuration Generator
 *
 * @name Generator
 */
Function Generator
✓ Was calledfunction Generator() {···
    this._config = {};
}
function Generator() {
    this._config = {};
}
/**
 * Generates a configuration object based for the given path
 * based on the best fitting preset
 *
 * @param  {String} path - The path containing file(s) used to guide the configuration
 *
 * @return {Promise} Resolved with the generated, JSCS configuration
 */
Function (anonymous_239)
✓ Was calledGenerator.prototype.generate = function(path) {···
    var checker = getChecker();
    var _path = utils.normalizePath(path, checker.getConfiguration().getBasePath());
    var presetNames = Object.keys(checker.getConfiguration().getRegisteredPresets());
    var statsForPresets;

    console.log('Checking', _path, 'against the presets');

    return Vow
    .all(presetNames.map(this._checkAgainstPreset.bind(this, _path)))
    .then(function(resultsPerPreset) {
        statsForPresets = this._generateStatsForPresets(resultsPerPreset, presetNames);
        return statsForPresets;
    }.bind(this))
    .then(this._showErrorCounts.bind(this))
    .then(this._getUserPresetChoice.bind(this, prompts[0]))
    .then(function showViolatedRules(choiceObj) {
        var presetIndex = choiceObj[prompts[0].name] - 1;
        var presetName = statsForPresets[presetIndex].name;

        console.log('You chose the ' + presetName + ' preset');

        this._config.preset = presetName;

        var errorStats = getErrorsByRuleName(statsForPresets[presetIndex].errors);

        var violatedRuleCount = Object.keys(errorStats).length;

        if (!violatedRuleCount) { return this._config; }

        console.log(_path + ' violates ' + violatedRuleCount + ' rule' + (violatedRuleCount > 1 ? 's' : ''));

        var errorPrompts = generateRuleHandlingPrompts(errorStats);

        return this._getUserViolationChoices(errorPrompts)
        .then(this._handleViolatedRules.bind(this, errorPrompts))
        .then(function() {
            return this._config;
        }.bind(this));
    }.bind(this))
    .then(function flushConfig() {
        fs.writeFileSync(process.cwd() + '/.jscsrc', JSON.stringify(this._config, null, '\t'));
        console.log('Generated a .jscsrc configuration file in ' + process.cwd());
    }.bind(this));
};
Generator.prototype.generate = function(path) {
    var checker = getChecker();
    var _path = utils.normalizePath(path, checker.getConfiguration().getBasePath());
    var presetNames = Object.keys(checker.getConfiguration().getRegisteredPresets());
    var statsForPresets;
    console.log('Checking', _path, 'against the presets');
    return Vow
    .all(presetNames.map(this._checkAgainstPreset.bind(this, _path)))
Function (anonymous_240)
✓ Was called    .then(function(resultsPerPreset) {···
        statsForPresets = this._generateStatsForPresets(resultsPerPreset, presetNames);
        return statsForPresets;
    }.bind(this))
    .then(function(resultsPerPreset) {
        statsForPresets = this._generateStatsForPresets(resultsPerPreset, presetNames);
        return statsForPresets;
    }.bind(this))
    .then(this._showErrorCounts.bind(this))
    .then(this._getUserPresetChoice.bind(this, prompts[0]))
Function showViolatedRules
✓ Was called    .then(function showViolatedRules(choiceObj) {···
        var presetIndex = choiceObj[prompts[0].name] - 1;
        var presetName = statsForPresets[presetIndex].name;

        console.log('You chose the ' + presetName + ' preset');

        this._config.preset = presetName;

        var errorStats = getErrorsByRuleName(statsForPresets[presetIndex].errors);

        var violatedRuleCount = Object.keys(errorStats).length;

        if (!violatedRuleCount) { return this._config; }

        console.log(_path + ' violates ' + violatedRuleCount + ' rule' + (violatedRuleCount > 1 ? 's' : ''));

        var errorPrompts = generateRuleHandlingPrompts(errorStats);

        return this._getUserViolationChoices(errorPrompts)
        .then(this._handleViolatedRules.bind(this, errorPrompts))
        .then(function() {
            return this._config;
        }.bind(this));
    }.bind(this))
    .then(function showViolatedRules(choiceObj) {
        var presetIndex = choiceObj[prompts[0].name] - 1;
        var presetName = statsForPresets[presetIndex].name;
        console.log('You chose the ' + presetName + ' preset');
        this._config.preset = presetName;
        var errorStats = getErrorsByRuleName(statsForPresets[presetIndex].errors);
        var violatedRuleCount = Object.keys(errorStats).length;
Branch IfStatement
✗ Positive was not executed (if)        if (!violatedRuleCount) { return this._config; }
✓ Negative was executed (else)        if (!violatedRuleCount) { return this._config; }···

        console.log(_path + ' violates ' + violatedRuleCount + ' rule' + (violatedRuleCount > 1 ? 's' : ''));
        if (!violatedRuleCount) { return this._config; }
Branch ConditionalExpression
✓ Positive was returned (? ...)        console.log(_path + ' violates ' + violatedRuleCount + ' rule' + (violatedRuleCount > 1 ? 's' : ''));
✗ Negative was not returned (: ...)        console.log(_path + ' violates ' + violatedRuleCount + ' rule' + (violatedRuleCount > 1 ? 's' : ''));
        console.log(_path + ' violates ' + violatedRuleCount + ' rule' + (violatedRuleCount > 1 ? 's' : ''));
        var errorPrompts = generateRuleHandlingPrompts(errorStats);
        return this._getUserViolationChoices(errorPrompts)
        .then(this._handleViolatedRules.bind(this, errorPrompts))
Function (anonymous_242)
✓ Was called        .then(function() {···
            return this._config;
        }.bind(this));
        .then(function() {
            return this._config;
        }.bind(this));
    }.bind(this))
Function flushConfig
✓ Was called    .then(function flushConfig() {···
        fs.writeFileSync(process.cwd() + '/.jscsrc', JSON.stringify(this._config, null, '\t'));
        console.log('Generated a .jscsrc configuration file in ' + process.cwd());
    }.bind(this));
    .then(function flushConfig() {
        fs.writeFileSync(process.cwd() + '/.jscsrc', JSON.stringify(this._config, null, '\t'));
        console.log('Generated a .jscsrc configuration file in ' + process.cwd());
    }.bind(this));
};
/**
 * @private
 * @param  {Object[][]} resultsPerPreset - List of error objects for each preset's run of checkPath
 * @param  {String[]} presetNames
 * @return {Object[]} Aggregated datapoints for each preset
 */
Function (anonymous_244)
✓ Was calledGenerator.prototype._generateStatsForPresets = function(resultsPerPreset, presetNames) {···
    return resultsPerPreset.map(function(presetResults, idx) {
        var errorCollection = [].concat.apply([], presetResults);

        var presetStats = {
            name: presetNames[idx],
            sum: 0,
            errors: []
        };

        errorCollection.forEach(function(error) {
            presetStats.sum += error.getErrorCount();
            presetStats.errors = presetStats.errors.concat(error.getErrorList());
        });

        return presetStats;
    });
};
Generator.prototype._generateStatsForPresets = function(resultsPerPreset, presetNames) {
Function (anonymous_245)
✓ Was called    return resultsPerPreset.map(function(presetResults, idx) {···
        var errorCollection = [].concat.apply([], presetResults);

        var presetStats = {
            name: presetNames[idx],
            sum: 0,
            errors: []
        };

        errorCollection.forEach(function(error) {
            presetStats.sum += error.getErrorCount();
            presetStats.errors = presetStats.errors.concat(error.getErrorList());
        });

        return presetStats;
    });
    return resultsPerPreset.map(function(presetResults, idx) {
        var errorCollection = [].concat.apply([], presetResults);
        var presetStats = {
            name: presetNames[idx],
            sum: 0,
            errors: []
        };
Function (anonymous_246)
✓ Was called        errorCollection.forEach(function(error) {···
            presetStats.sum += error.getErrorCount();
            presetStats.errors = presetStats.errors.concat(error.getErrorList());
        });
        errorCollection.forEach(function(error) {
            presetStats.sum += error.getErrorCount();
            presetStats.errors = presetStats.errors.concat(error.getErrorList());
        });
        return presetStats;
    });
};
/**
 * @private
 * @param  {Object[]} statsForPresets
 */
Function (anonymous_247)
✓ Was calledGenerator.prototype._showErrorCounts = function(statsForPresets) {···
    var table = getTable();

    statsForPresets.forEach(function(presetStats, idx) {
        table.push([idx + 1, presetStats.name, presetStats.sum, getUniqueErrorNames(presetStats.errors).length]);
    });

    console.log(table.toString());
};
Generator.prototype._showErrorCounts = function(statsForPresets) {
    var table = getTable();
Function (anonymous_248)
✓ Was called    statsForPresets.forEach(function(presetStats, idx) {···
        table.push([idx + 1, presetStats.name, presetStats.sum, getUniqueErrorNames(presetStats.errors).length]);
    });
    statsForPresets.forEach(function(presetStats, idx) {
        table.push([idx + 1, presetStats.name, presetStats.sum, getUniqueErrorNames(presetStats.errors).length]);
    });
    console.log(table.toString());
};
/**
 * Prompts the user to choose a preset
 *
 * @private
 * @param {Object} prompt
 * @return {Promise}
 */
Function (anonymous_249)
✓ Was calledGenerator.prototype._getUserPresetChoice = function(prompt) {···
    return this._showPrompt(prompt);
};
Generator.prototype._getUserPresetChoice = function(prompt) {
    return this._showPrompt(prompt);
};
/**
 * Prompts the user to nullify rules or fix violations themselves
 *
 * @private
 * @param  {Object[]} errorPrompts
 * @return {Promise}
 */
Function (anonymous_250)
✓ Was calledGenerator.prototype._getUserViolationChoices = function(errorPrompts) {···
    return this._showPrompt(errorPrompts);
};
Generator.prototype._getUserViolationChoices = function(errorPrompts) {
    return this._showPrompt(errorPrompts);
};
/** @private */
Generator.prototype._showPrompt = utils.promisify(prompt.get.bind(prompt));
/**
 * @private
 * @param  {Object[]} errorPrompts
 * @param  {String[]} errorList
 * @param  {Object[]} choices
 */
Function (anonymous_251)
✓ Was calledGenerator.prototype._handleViolatedRules = function(errorPrompts, choices) {···
    errorPrompts.forEach(function(errorPrompt) {
        var userChoice = choices[errorPrompt.name];

        if (userChoice.toLowerCase() === 'e') {
            this._config[errorPrompt.associatedRuleName] = null;
        }
    }, this);
};
Generator.prototype._handleViolatedRules = function(errorPrompts, choices) {
Function (anonymous_252)
✓ Was called    errorPrompts.forEach(function(errorPrompt) {···
        var userChoice = choices[errorPrompt.name];

        if (userChoice.toLowerCase() === 'e') {
            this._config[errorPrompt.associatedRuleName] = null;
        }
    }, this);
    errorPrompts.forEach(function(errorPrompt) {
        var userChoice = choices[errorPrompt.name];
Branch IfStatement
✓ Positive was executed (if)        if (userChoice.toLowerCase() === 'e') {···
            this._config[errorPrompt.associatedRuleName] = null;
        }
✗ Negative was not executed (else)        }···
    }, this);
        if (userChoice.toLowerCase() === 'e') {
            this._config[errorPrompt.associatedRuleName] = null;
        }
    }, this);
};
/**
 * @private
 * @param  {String} path
 * @param  {String} presetName
 * @return {Promise}
 */
Function (anonymous_253)
✓ Was calledGenerator.prototype._checkAgainstPreset = function(path, presetName) {···
    var checker = getChecker();

    checker.configure({preset: presetName});

    return checker.checkPath(path);
};
Generator.prototype._checkAgainstPreset = function(path, presetName) {
    var checker = getChecker();
    checker.configure({preset: presetName});
    return checker.checkPath(path);
};
/**
 * @private
 * @return {lib/Checker}
 */
Function getChecker
✓ Was calledfunction getChecker() {···
    var checker = new Checker();
    checker.registerDefaultRules();
    return checker;
}
function getChecker() {
    var checker = new Checker();
    checker.registerDefaultRules();
    return checker;
}
/**
 * @private
 * @param  {Object} errors
 * @return {Object[]}
 */
Function generateRuleHandlingPrompts
✓ Was calledfunction generateRuleHandlingPrompts(errors) {···
    // Generate list of rule names, sorted by violation count (descending)
    var violatedRuleNames = Object.keys(errors);
    violatedRuleNames.sort(function(a, b) {
        return errors[b].violations - errors[a].violations;
    });

    return violatedRuleNames.map(function(ruleName) {
        var violationCount = errors[ruleName].violations;
        var fileCount = Object.keys(errors[ruleName].files).length;
        var prompt = assign({}, prompts[1]);

        prompt.associatedRuleName = ruleName;
        prompt.name = chalk.green(ruleName) +
            ' (' + violationCount + ' violation' + (violationCount > 1 ? 's' : '') +
            ' in ' + fileCount + ' file' + (fileCount > 1 ? 's' : '') + '):\n    ' +
            prompt.name;
        return prompt;
    });
}
function generateRuleHandlingPrompts(errors) {
    // Generate list of rule names, sorted by violation count (descending)
    var violatedRuleNames = Object.keys(errors);
Function (anonymous_256)
✓ Was called    violatedRuleNames.sort(function(a, b) {···
        return errors[b].violations - errors[a].violations;
    });
    violatedRuleNames.sort(function(a, b) {
        return errors[b].violations - errors[a].violations;
    });
Function (anonymous_257)
✓ Was called    return violatedRuleNames.map(function(ruleName) {···
        var violationCount = errors[ruleName].violations;
        var fileCount = Object.keys(errors[ruleName].files).length;
        var prompt = assign({}, prompts[1]);

        prompt.associatedRuleName = ruleName;
        prompt.name = chalk.green(ruleName) +
            ' (' + violationCount + ' violation' + (violationCount > 1 ? 's' : '') +
            ' in ' + fileCount + ' file' + (fileCount > 1 ? 's' : '') + '):\n    ' +
            prompt.name;
        return prompt;
    });
    return violatedRuleNames.map(function(ruleName) {
        var violationCount = errors[ruleName].violations;
        var fileCount = Object.keys(errors[ruleName].files).length;
        var prompt = assign({}, prompts[1]);
        prompt.associatedRuleName = ruleName;
        prompt.name = chalk.green(ruleName) +
Branch ConditionalExpression
✓ Positive was returned (? ...)            ' (' + violationCount + ' violation' + (violationCount > 1 ? 's' : '') +
✓ Negative was returned (: ...)            ' (' + violationCount + ' violation' + (violationCount > 1 ? 's' : '') +
            ' (' + violationCount + ' violation' + (violationCount > 1 ? 's' : '') +
Branch ConditionalExpression
✗ Positive was not returned (? ...)            ' in ' + fileCount + ' file' + (fileCount > 1 ? 's' : '') + '):\n    ' +
✓ Negative was returned (: ...)            ' in ' + fileCount + ' file' + (fileCount > 1 ? 's' : '') + '):\n    ' +
            ' in ' + fileCount + ' file' + (fileCount > 1 ? 's' : '') + '):\n    ' +
            prompt.name;
        return prompt;
    });
}
/**
 * @private
 * @param  {Object[]} errorList
 * @return {Object}
 */
Function getErrorsByRuleName
✓ Was calledfunction getErrorsByRuleName(errorsList) {···
    var errors = {};

    errorsList.forEach(function(error) {
        var rulename = error.rule;
        errors[rulename] = errors[rulename] || {
            files: {},
            violations: 0
        };
        errors[rulename].violations += 1;
        errors[rulename].files[error.filename] = true;
    });

    return errors;
}
function getErrorsByRuleName(errorsList) {
    var errors = {};
Function (anonymous_259)
✓ Was called    errorsList.forEach(function(error) {···
        var rulename = error.rule;
        errors[rulename] = errors[rulename] || {
            files: {},
            violations: 0
        };
        errors[rulename].violations += 1;
        errors[rulename].files[error.filename] = true;
    });
    errorsList.forEach(function(error) {
        var rulename = error.rule;
Branch LogicalExpression
✓ Was returned        errors[rulename] = errors[rulename] || {···
            files: {},
            violations: 0
        };
✓ Was returned        errors[rulename] = errors[rulename] || {
        errors[rulename] = errors[rulename] || {
            files: {},
            violations: 0
        };
        errors[rulename].violations += 1;
        errors[rulename].files[error.filename] = true;
    });
    return errors;
}
/**
 * @private
 * @param  {Object[]} errorsList
 * @return {String[]}
 */
Function getUniqueErrorNames
✓ Was calledfunction getUniqueErrorNames(errorsList) {···
    var errorNameLUT = {};

    errorsList.forEach(function(error) {
        errorNameLUT[error.rule] = true;
    });

    return Object.keys(errorNameLUT);
}
function getUniqueErrorNames(errorsList) {
    var errorNameLUT = {};
Function (anonymous_261)
✓ Was called    errorsList.forEach(function(error) {···
        errorNameLUT[error.rule] = true;
    });
    errorsList.forEach(function(error) {
        errorNameLUT[error.rule] = true;
    });
    return Object.keys(errorNameLUT);
}
/**
 * @private
 * @return {Object}
 */
Function getTable
✓ Was calledfunction getTable() {···
    return new Table({
        chars: {
            top: '', 'top-mid': '', 'top-left': '', 'top-right': '',
            bottom: '', 'bottom-mid': '', 'bottom-left': '', 'bottom-right': '',
            left: '', 'left-mid': '',
            mid: '', 'mid-mid': '',
            right: '', 'right-mid': '' ,
            middle: ' '
        },
        style: {
            'padding-left': 0,
            'padding-right': 0
        },
        head: ['', 'Preset', '#Errors', '#Rules']
    });
}
function getTable() {
    return new Table({
        chars: {
            top: '', 'top-mid': '', 'top-left': '', 'top-right': '',
            bottom: '', 'bottom-mid': '', 'bottom-left': '', 'bottom-right': '',
            left: '', 'left-mid': '',
            mid: '', 'mid-mid': '',
            right: '', 'right-mid': '' ,
            middle: ' '
        },
        style: {
            'padding-left': 0,
            'padding-right': 0
        },
        head: ['', 'Preset', '#Errors', '#Rules']
    });
}
module.exports = Generator;

checkstyle.js
Function escapeAttrValue
✓ Was calledfunction escapeAttrValue(attrValue) {···
    return String(attrValue)
        .replace(/&/g, '&amp;')
        .replace(/"/g, '&quot;')
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;');
}
function escapeAttrValue(attrValue) {
    return String(attrValue)
        .replace(/&/g, '&amp;')
        .replace(/"/g, '&quot;')
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;');
}
Function (anonymous_264)
✓ Was calledmodule.exports = function(errorCollection) {···
    console.log('<?xml version="1.0" encoding="utf-8"?>\n<checkstyle version="4.3">');
    errorCollection.forEach(function(errors) {
        console.log('    <file name="' + escapeAttrValue(errors.getFilename()) + '">');
        errors.getErrorList().forEach(function(error) {
            console.log(
                '        <error ' +
                'line="' + error.line + '" ' +
                'column="' + (error.column + 1) + '" ' +
                'severity="error" ' +
                'message="' + escapeAttrValue(error.message) + '" ' +
                'source="jscs" />'
            );
        });
        console.log('    </file>');
    });
    console.log('</checkstyle>');
};
module.exports = function(errorCollection) {
    console.log('<?xml version="1.0" encoding="utf-8"?>\n<checkstyle version="4.3">');
Function (anonymous_265)
✓ Was called    errorCollection.forEach(function(errors) {···
        console.log('    <file name="' + escapeAttrValue(errors.getFilename()) + '">');
        errors.getErrorList().forEach(function(error) {
            console.log(
                '        <error ' +
                'line="' + error.line + '" ' +
                'column="' + (error.column + 1) + '" ' +
                'severity="error" ' +
                'message="' + escapeAttrValue(error.message) + '" ' +
                'source="jscs" />'
            );
        });
        console.log('    </file>');
    });
    errorCollection.forEach(function(errors) {
        console.log('    <file name="' + escapeAttrValue(errors.getFilename()) + '">');
Function (anonymous_266)
✓ Was called        errors.getErrorList().forEach(function(error) {···
            console.log(
                '        <error ' +
                'line="' + error.line + '" ' +
                'column="' + (error.column + 1) + '" ' +
                'severity="error" ' +
                'message="' + escapeAttrValue(error.message) + '" ' +
                'source="jscs" />'
            );
        });
        errors.getErrorList().forEach(function(error) {
            console.log(
                '        <error ' +
                'line="' + error.line + '" ' +
                'column="' + (error.column + 1) + '" ' +
                'severity="error" ' +
                'message="' + escapeAttrValue(error.message) + '" ' +
                'source="jscs" />'
            );
        });
        console.log('    </file>');
    });
    console.log('</checkstyle>');
};

require-curly-braces.js
/**
 * Requires curly braces after statements.
 *
 * Types: `Array` or `Boolean`
 *
 * Values: Array of quoted keywords or `true` to require curly braces after the following keywords:
 *
 * JSHint: [`curly`](http://jshint.com/docs/options/#curly)
 *
 * #### Example
 *
 * ```js
 * "requireCurlyBraces": [
 *     "if",
 *     "else",
 *     "for",
 *     "while",
 *     "do",
 *     "try",
 *     "catch",
 *     "case",
 *     "default"
 * ]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * if (x) {
 *     x++;
 * }
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * if (x) x++;
 * ```
 */
var assert = require('assert');
var defaultKeywords = require('../utils').curlyBracedKeywords;
Function (anonymous_267)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_268)
✓ Was called    configure: function(statementTypes) {···
        assert(
            Array.isArray(statementTypes) || statementTypes === true,
            this.getOptionName() + ' option requires array or true value'
        );

        if (statementTypes === true) {
            statementTypes = defaultKeywords;
        }

        this._typeIndex = {};
        for (var i = 0, l = statementTypes.length; i < l; i++) {
            this._typeIndex[statementTypes[i]] = true;
        }
    },
    configure: function(statementTypes) {
        assert(
Branch LogicalExpression
✓ Was returned            Array.isArray(statementTypes) || statementTypes === true,
✓ Was returned            Array.isArray(statementTypes) || statementTypes === true,
            Array.isArray(statementTypes) || statementTypes === true,
            this.getOptionName() + ' option requires array or true value'
        );
Branch IfStatement
✓ Positive was executed (if)        if (statementTypes === true) {···
            statementTypes = defaultKeywords;
        }
✓ Negative was executed (else)        }···

        this._typeIndex = {};
        if (statementTypes === true) {
            statementTypes = defaultKeywords;
        }
        this._typeIndex = {};
        for (var i = 0, l = statementTypes.length; i < l; i++) {
            this._typeIndex[statementTypes[i]] = true;
        }
    },
Function (anonymous_269)
✓ Was called    getOptionName: function() {···
        return 'requireCurlyBraces';
    },
    getOptionName: function() {
        return 'requireCurlyBraces';
    },
Function (anonymous_270)
✓ Was called    check: function(file, errors) {···

        function isNotABlockStatement(node) {
            return node && node.type !== 'BlockStatement';
        }

        function addError(typeString, entity) {
            errors.add(
                typeString + ' statement without curly braces',
                entity.loc.start.line,
                entity.loc.start.column
            );
        }

        function checkBody(type, typeString) {
            file.iterateNodesByType(type, function(node) {
                if (isNotABlockStatement(node.body)) {
                    addError(typeString, node);
                }
            });
        }

        var typeIndex = this._typeIndex;

        if (typeIndex['if'] || typeIndex['else']) {
            file.iterateNodesByType('IfStatement', function(node) {
                if (typeIndex['if'] && isNotABlockStatement(node.consequent)) {
                    addError('If', node);
                }
                if (typeIndex['else'] && isNotABlockStatement(node.alternate) &&
                    node.alternate.type !== 'IfStatement') {
                    addError('Else', file.getPrevToken(file.getFirstNodeToken(node.alternate)));
                }
            });
        }

        if (typeIndex['case'] || typeIndex['default']) {
            file.iterateNodesByType('SwitchCase', function(node) {
                // empty case statement
                if (node.consequent.length === 0) {
                    return;
                }

                if (node.consequent.length === 1 && node.consequent[0].type === 'BlockStatement') {
                    return;
                }

                if (node.test === null && typeIndex['default']) {
                    addError('Default', node);
                }

                if (node.test !== null && typeIndex['case']) {
                    addError('Case', node);
                }
            });
        }

        if (typeIndex['while']) {
            checkBody('WhileStatement', 'While');
        }

        if (typeIndex['for']) {
            checkBody('ForStatement', 'For');
            checkBody('ForInStatement', 'For in');
        }

        if (typeIndex['do']) {
            checkBody('DoWhileStatement', 'Do while');
        }

        if (typeIndex['with']) {
            checkBody('WithStatement', 'With');
        }
    }
    check: function(file, errors) {
Function isNotABlockStatement
✓ Was called        function isNotABlockStatement(node) {···
            return node && node.type !== 'BlockStatement';
        }
        function isNotABlockStatement(node) {
Branch LogicalExpression
✓ Was returned            return node && node.type !== 'BlockStatement';
✓ Was returned            return node && node.type !== 'BlockStatement';
            return node && node.type !== 'BlockStatement';
        }
Function addError
✓ Was called        function addError(typeString, entity) {···
            errors.add(
                typeString + ' statement without curly braces',
                entity.loc.start.line,
                entity.loc.start.column
            );
        }
        function addError(typeString, entity) {
            errors.add(
                typeString + ' statement without curly braces',
                entity.loc.start.line,
                entity.loc.start.column
            );
        }
Function checkBody
✓ Was called        function checkBody(type, typeString) {···
            file.iterateNodesByType(type, function(node) {
                if (isNotABlockStatement(node.body)) {
                    addError(typeString, node);
                }
            });
        }
        function checkBody(type, typeString) {
Function (anonymous_274)
✓ Was called            file.iterateNodesByType(type, function(node) {···
                if (isNotABlockStatement(node.body)) {
                    addError(typeString, node);
                }
            });
            file.iterateNodesByType(type, function(node) {
Branch IfStatement
✓ Positive was executed (if)                if (isNotABlockStatement(node.body)) {···
                    addError(typeString, node);
                }
✓ Negative was executed (else)                }···
            });
                if (isNotABlockStatement(node.body)) {
                    addError(typeString, node);
                }
            });
        }
        var typeIndex = this._typeIndex;
Branch IfStatement
✓ Positive was executed (if)        if (typeIndex['if'] || typeIndex['else']) {···
            file.iterateNodesByType('IfStatement', function(node) {
                if (typeIndex['if'] && isNotABlockStatement(node.consequent)) {
                    addError('If', node);
                }
                if (typeIndex['else'] && isNotABlockStatement(node.alternate) &&
                    node.alternate.type !== 'IfStatement') {
                    addError('Else', file.getPrevToken(file.getFirstNodeToken(node.alternate)));
                }
            });
        }
✓ Negative was executed (else)        }···

        if (typeIndex['case'] || typeIndex['default']) {
Branch LogicalExpression
✓ Was returned        if (typeIndex['if'] || typeIndex['else']) {
✓ Was returned        if (typeIndex['if'] || typeIndex['else']) {
        if (typeIndex['if'] || typeIndex['else']) {
Function (anonymous_275)
✓ Was called            file.iterateNodesByType('IfStatement', function(node) {···
                if (typeIndex['if'] && isNotABlockStatement(node.consequent)) {
                    addError('If', node);
                }
                if (typeIndex['else'] && isNotABlockStatement(node.alternate) &&
                    node.alternate.type !== 'IfStatement') {
                    addError('Else', file.getPrevToken(file.getFirstNodeToken(node.alternate)));
                }
            });
            file.iterateNodesByType('IfStatement', function(node) {
Branch IfStatement
✓ Positive was executed (if)                if (typeIndex['if'] && isNotABlockStatement(node.consequent)) {···
                    addError('If', node);
                }
✓ Negative was executed (else)                }···
                if (typeIndex['else'] && isNotABlockStatement(node.alternate) &&
Branch LogicalExpression
✓ Was returned                if (typeIndex['if'] && isNotABlockStatement(node.consequent)) {
✓ Was returned                if (typeIndex['if'] && isNotABlockStatement(node.consequent)) {
                if (typeIndex['if'] && isNotABlockStatement(node.consequent)) {
                    addError('If', node);
                }
Branch IfStatement
✓ Positive was executed (if)                    node.alternate.type !== 'IfStatement') {···
                    addError('Else', file.getPrevToken(file.getFirstNodeToken(node.alternate)));
                }
✓ Negative was executed (else)                }···
            });
Branch LogicalExpression
✓ Was returned                    node.alternate.type !== 'IfStatement') {
✓ Was returned                if (typeIndex['else'] && isNotABlockStatement(node.alternate) &&
Branch LogicalExpression
✓ Was returned                if (typeIndex['else'] && isNotABlockStatement(node.alternate) &&
✓ Was returned                if (typeIndex['else'] && isNotABlockStatement(node.alternate) &&
                if (typeIndex['else'] && isNotABlockStatement(node.alternate) &&
                    node.alternate.type !== 'IfStatement') {
                    addError('Else', file.getPrevToken(file.getFirstNodeToken(node.alternate)));
                }
            });
        }
Branch IfStatement
✓ Positive was executed (if)        if (typeIndex['case'] || typeIndex['default']) {···
            file.iterateNodesByType('SwitchCase', function(node) {
                // empty case statement
                if (node.consequent.length === 0) {
                    return;
                }

                if (node.consequent.length === 1 && node.consequent[0].type === 'BlockStatement') {
                    return;
                }

                if (node.test === null && typeIndex['default']) {
                    addError('Default', node);
                }

                if (node.test !== null && typeIndex['case']) {
                    addError('Case', node);
                }
            });
        }
✓ Negative was executed (else)        }···

        if (typeIndex['while']) {
Branch LogicalExpression
✓ Was returned        if (typeIndex['case'] || typeIndex['default']) {
✓ Was returned        if (typeIndex['case'] || typeIndex['default']) {
        if (typeIndex['case'] || typeIndex['default']) {
Function (anonymous_276)
✓ Was called            file.iterateNodesByType('SwitchCase', function(node) {···
                // empty case statement
                if (node.consequent.length === 0) {
                    return;
                }

                if (node.consequent.length === 1 && node.consequent[0].type === 'BlockStatement') {
                    return;
                }

                if (node.test === null && typeIndex['default']) {
                    addError('Default', node);
                }

                if (node.test !== null && typeIndex['case']) {
                    addError('Case', node);
                }
            });
            file.iterateNodesByType('SwitchCase', function(node) {
                // empty case statement
Branch IfStatement
✓ Positive was executed (if)                if (node.consequent.length === 0) {···
                    return;
                }
✓ Negative was executed (else)                }···

                if (node.consequent.length === 1 && node.consequent[0].type === 'BlockStatement') {
                if (node.consequent.length === 0) {
                    return;
                }
Branch IfStatement
✓ Positive was executed (if)                if (node.consequent.length === 1 && node.consequent[0].type === 'BlockStatement') {···
                    return;
                }
✓ Negative was executed (else)                }···

                if (node.test === null && typeIndex['default']) {
Branch LogicalExpression
✓ Was returned                if (node.consequent.length === 1 && node.consequent[0].type === 'BlockStatement') {
✓ Was returned                if (node.consequent.length === 1 && node.consequent[0].type === 'BlockStatement') {
                if (node.consequent.length === 1 && node.consequent[0].type === 'BlockStatement') {
                    return;
                }
Branch IfStatement
✓ Positive was executed (if)                if (node.test === null && typeIndex['default']) {···
                    addError('Default', node);
                }
✓ Negative was executed (else)                }···

                if (node.test !== null && typeIndex['case']) {
Branch LogicalExpression
✓ Was returned                if (node.test === null && typeIndex['default']) {
✓ Was returned                if (node.test === null && typeIndex['default']) {
                if (node.test === null && typeIndex['default']) {
                    addError('Default', node);
                }
Branch IfStatement
✓ Positive was executed (if)                if (node.test !== null && typeIndex['case']) {···
                    addError('Case', node);
                }
✓ Negative was executed (else)                }···
            });
Branch LogicalExpression
✓ Was returned                if (node.test !== null && typeIndex['case']) {
✓ Was returned                if (node.test !== null && typeIndex['case']) {
                if (node.test !== null && typeIndex['case']) {
                    addError('Case', node);
                }
            });
        }
Branch IfStatement
✓ Positive was executed (if)        if (typeIndex['while']) {···
            checkBody('WhileStatement', 'While');
        }
✓ Negative was executed (else)        }···

        if (typeIndex['for']) {
        if (typeIndex['while']) {
            checkBody('WhileStatement', 'While');
        }
Branch IfStatement
✓ Positive was executed (if)        if (typeIndex['for']) {···
            checkBody('ForStatement', 'For');
            checkBody('ForInStatement', 'For in');
        }
✓ Negative was executed (else)        }···

        if (typeIndex['do']) {
        if (typeIndex['for']) {
            checkBody('ForStatement', 'For');
            checkBody('ForInStatement', 'For in');
        }
Branch IfStatement
✓ Positive was executed (if)        if (typeIndex['do']) {···
            checkBody('DoWhileStatement', 'Do while');
        }
✓ Negative was executed (else)        }···

        if (typeIndex['with']) {
        if (typeIndex['do']) {
            checkBody('DoWhileStatement', 'Do while');
        }
Branch IfStatement
✓ Positive was executed (if)        if (typeIndex['with']) {···
            checkBody('WithStatement', 'With');
        }
✓ Negative was executed (else)        }···
    }
        if (typeIndex['with']) {
            checkBody('WithStatement', 'With');
        }
    }
};

disallow-curly-braces.js
/**
 * Disallows curly braces after statements.
 *
 * Types: `Array` or `Boolean`
 *
 * Values: Array of quoted keywords or `true` to disallow curly braces after the following keywords:
 *
 * #### Example
 *
 * ```js
 * "disallowCurlyBraces": [
 *     "if",
 *     "else",
 *     "while",
 *     "for",
 *     "do",
 *     "with"
 * ]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * if (x) x++;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * if (x) {
 *     x++;
 * }
 * ```
 */
var assert = require('assert');
var defaultKeywords = require('../utils').curlyBracedKeywords;
Function (anonymous_277)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_278)
✓ Was called    configure: function(statementTypes) {···
        assert(
            Array.isArray(statementTypes) || statementTypes === true,
            this.getOptionName() + ' option requires array or true value'
        );

        if (statementTypes === true) {
            statementTypes = defaultKeywords;
        }

        this._typeIndex = {};
        statementTypes.forEach(function(type) {
            this._typeIndex[type] = true;
        }.bind(this));
    },
    configure: function(statementTypes) {
        assert(
Branch LogicalExpression
✓ Was returned            Array.isArray(statementTypes) || statementTypes === true,
✓ Was returned            Array.isArray(statementTypes) || statementTypes === true,
            Array.isArray(statementTypes) || statementTypes === true,
            this.getOptionName() + ' option requires array or true value'
        );
Branch IfStatement
✓ Positive was executed (if)        if (statementTypes === true) {···
            statementTypes = defaultKeywords;
        }
✓ Negative was executed (else)        }···

        this._typeIndex = {};
        if (statementTypes === true) {
            statementTypes = defaultKeywords;
        }
        this._typeIndex = {};
Function (anonymous_279)
✓ Was called        statementTypes.forEach(function(type) {···
            this._typeIndex[type] = true;
        }.bind(this));
        statementTypes.forEach(function(type) {
            this._typeIndex[type] = true;
        }.bind(this));
    },
Function (anonymous_280)
✓ Was called    getOptionName: function() {···
        return 'disallowCurlyBraces';
    },
    getOptionName: function() {
        return 'disallowCurlyBraces';
    },
Function (anonymous_281)
✓ Was called    check: function(file, errors) {···

        function isSingleBlockStatement(node) {
            return node && node.type === 'BlockStatement' &&
            node.body.length === 1;
        }

        function addError(typeString, entity) {
            errors.add(
                typeString + ' statement with extra curly braces',
                entity.loc.start.line,
                entity.loc.start.column
            );
        }

        function checkBody(type, typeString) {
            file.iterateNodesByType(type, function(node) {
                if (isSingleBlockStatement(node.body)) {
                    addError(typeString, node);
                }
            });
        }

        var typeIndex = this._typeIndex;

        if (typeIndex['if'] || typeIndex['else']) {
            file.iterateNodesByType('IfStatement', function(node) {
                if (typeIndex['if'] && isSingleBlockStatement(node.consequent)) {
                    addError('If', node);
                }
                if (typeIndex['else'] && isSingleBlockStatement(node.alternate)) {
                    addError('Else', file.getPrevToken(file.getFirstNodeToken(node.alternate)));
                }
            });
        }

        if (typeIndex['while']) {
            checkBody('WhileStatement', 'While');
        }

        if (typeIndex['for']) {
            checkBody('ForStatement', 'For');
            checkBody('ForInStatement', 'For in');
        }

        if (typeIndex['do']) {
            checkBody('DoWhileStatement', 'Do while');
        }

        if (typeIndex['with']) {
            checkBody('WithStatement', 'With');
        }
    }
    check: function(file, errors) {
Function isSingleBlockStatement
✓ Was called        function isSingleBlockStatement(node) {···
            return node && node.type === 'BlockStatement' &&
            node.body.length === 1;
        }
        function isSingleBlockStatement(node) {
Branch LogicalExpression
✓ Was returned            node.body.length === 1;
✓ Was returned            return node && node.type === 'BlockStatement' &&
Branch LogicalExpression
✓ Was returned            return node && node.type === 'BlockStatement' &&
✓ Was returned            return node && node.type === 'BlockStatement' &&
            return node && node.type === 'BlockStatement' &&
            node.body.length === 1;
        }
Function addError
✓ Was called        function addError(typeString, entity) {···
            errors.add(
                typeString + ' statement with extra curly braces',
                entity.loc.start.line,
                entity.loc.start.column
            );
        }
        function addError(typeString, entity) {
            errors.add(
                typeString + ' statement with extra curly braces',
                entity.loc.start.line,
                entity.loc.start.column
            );
        }
Function checkBody
✓ Was called        function checkBody(type, typeString) {···
            file.iterateNodesByType(type, function(node) {
                if (isSingleBlockStatement(node.body)) {
                    addError(typeString, node);
                }
            });
        }
        function checkBody(type, typeString) {
Function (anonymous_285)
✓ Was called            file.iterateNodesByType(type, function(node) {···
                if (isSingleBlockStatement(node.body)) {
                    addError(typeString, node);
                }
            });
            file.iterateNodesByType(type, function(node) {
Branch IfStatement
✓ Positive was executed (if)                if (isSingleBlockStatement(node.body)) {···
                    addError(typeString, node);
                }
✓ Negative was executed (else)                }···
            });
                if (isSingleBlockStatement(node.body)) {
                    addError(typeString, node);
                }
            });
        }
        var typeIndex = this._typeIndex;
Branch IfStatement
✓ Positive was executed (if)        if (typeIndex['if'] || typeIndex['else']) {···
            file.iterateNodesByType('IfStatement', function(node) {
                if (typeIndex['if'] && isSingleBlockStatement(node.consequent)) {
                    addError('If', node);
                }
                if (typeIndex['else'] && isSingleBlockStatement(node.alternate)) {
                    addError('Else', file.getPrevToken(file.getFirstNodeToken(node.alternate)));
                }
            });
        }
✓ Negative was executed (else)        }···

        if (typeIndex['while']) {
Branch LogicalExpression
✓ Was returned        if (typeIndex['if'] || typeIndex['else']) {
✓ Was returned        if (typeIndex['if'] || typeIndex['else']) {
        if (typeIndex['if'] || typeIndex['else']) {
Function (anonymous_286)
✓ Was called            file.iterateNodesByType('IfStatement', function(node) {···
                if (typeIndex['if'] && isSingleBlockStatement(node.consequent)) {
                    addError('If', node);
                }
                if (typeIndex['else'] && isSingleBlockStatement(node.alternate)) {
                    addError('Else', file.getPrevToken(file.getFirstNodeToken(node.alternate)));
                }
            });
            file.iterateNodesByType('IfStatement', function(node) {
Branch IfStatement
✓ Positive was executed (if)                if (typeIndex['if'] && isSingleBlockStatement(node.consequent)) {···
                    addError('If', node);
                }
✓ Negative was executed (else)                }···
                if (typeIndex['else'] && isSingleBlockStatement(node.alternate)) {
Branch LogicalExpression
✓ Was returned                if (typeIndex['if'] && isSingleBlockStatement(node.consequent)) {
✓ Was returned                if (typeIndex['if'] && isSingleBlockStatement(node.consequent)) {
                if (typeIndex['if'] && isSingleBlockStatement(node.consequent)) {
                    addError('If', node);
                }
Branch IfStatement
✓ Positive was executed (if)                if (typeIndex['else'] && isSingleBlockStatement(node.alternate)) {···
                    addError('Else', file.getPrevToken(file.getFirstNodeToken(node.alternate)));
                }
✓ Negative was executed (else)                }···
            });
Branch LogicalExpression
✓ Was returned                if (typeIndex['else'] && isSingleBlockStatement(node.alternate)) {
✓ Was returned                if (typeIndex['else'] && isSingleBlockStatement(node.alternate)) {
                if (typeIndex['else'] && isSingleBlockStatement(node.alternate)) {
                    addError('Else', file.getPrevToken(file.getFirstNodeToken(node.alternate)));
                }
            });
        }
Branch IfStatement
✓ Positive was executed (if)        if (typeIndex['while']) {···
            checkBody('WhileStatement', 'While');
        }
✓ Negative was executed (else)        }···

        if (typeIndex['for']) {
        if (typeIndex['while']) {
            checkBody('WhileStatement', 'While');
        }
Branch IfStatement
✓ Positive was executed (if)        if (typeIndex['for']) {···
            checkBody('ForStatement', 'For');
            checkBody('ForInStatement', 'For in');
        }
✓ Negative was executed (else)        }···

        if (typeIndex['do']) {
        if (typeIndex['for']) {
            checkBody('ForStatement', 'For');
            checkBody('ForInStatement', 'For in');
        }
Branch IfStatement
✓ Positive was executed (if)        if (typeIndex['do']) {···
            checkBody('DoWhileStatement', 'Do while');
        }
✓ Negative was executed (else)        }···

        if (typeIndex['with']) {
        if (typeIndex['do']) {
            checkBody('DoWhileStatement', 'Do while');
        }
Branch IfStatement
✓ Positive was executed (if)        if (typeIndex['with']) {···
            checkBody('WithStatement', 'With');
        }
✓ Negative was executed (else)        }···
    }
        if (typeIndex['with']) {
            checkBody('WithStatement', 'With');
        }
    }
};

require-multiple-var-decl.js
/**
 * Requires multiple `var` declaration.
 *
 * Types: `Boolean` or `String`
 *
 * Values: `true` or `"onevar"`
 *
 * if `requireMultipleVarDecl` defined as a `true` value, it will report only consecutive vars, if, on the other hand,
 * value equals to `"onevar"` string, `requireMultipleVarDecl` will allow only one `var` per function scope.
 *
 * JSHint: [`onevar`](http://jshint.com/docs/options/#onevar)
 *
 * #### Example
 *
 * ```js
 * "requireMultipleVarDecl": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var x = 1,
 *     y = 2;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = 1;
 * var y = 2;
 * ```
 */
var assert = require('assert');
Function consecutive
✓ Was calledfunction consecutive(file, errors) {···
    file.iterateNodesByType('VariableDeclaration', function(node) {
        var pos = node.parentCollection.indexOf(node);
        if (pos < node.parentCollection.length - 1) {
            var sibling = node.parentCollection[pos + 1];
            if (sibling.type === 'VariableDeclaration' && sibling.kind === node.kind) {
                errors.add(
                    node.kind[0].toUpperCase() + node.kind.slice(1) + ' declarations should be joined',
                    sibling.loc.start
                );
            }
        }
    });
}
function consecutive(file, errors) {
Function (anonymous_288)
✓ Was called    file.iterateNodesByType('VariableDeclaration', function(node) {···
        var pos = node.parentCollection.indexOf(node);
        if (pos < node.parentCollection.length - 1) {
            var sibling = node.parentCollection[pos + 1];
            if (sibling.type === 'VariableDeclaration' && sibling.kind === node.kind) {
                errors.add(
                    node.kind[0].toUpperCase() + node.kind.slice(1) + ' declarations should be joined',
                    sibling.loc.start
                );
            }
        }
    });
    file.iterateNodesByType('VariableDeclaration', function(node) {
        var pos = node.parentCollection.indexOf(node);
Branch IfStatement
✓ Positive was executed (if)        if (pos < node.parentCollection.length - 1) {···
            var sibling = node.parentCollection[pos + 1];
            if (sibling.type === 'VariableDeclaration' && sibling.kind === node.kind) {
                errors.add(
                    node.kind[0].toUpperCase() + node.kind.slice(1) + ' declarations should be joined',
                    sibling.loc.start
                );
            }
        }
✓ Negative was executed (else)        }···
    });
        if (pos < node.parentCollection.length - 1) {
            var sibling = node.parentCollection[pos + 1];
Branch IfStatement
✓ Positive was executed (if)            if (sibling.type === 'VariableDeclaration' && sibling.kind === node.kind) {···
                errors.add(
                    node.kind[0].toUpperCase() + node.kind.slice(1) + ' declarations should be joined',
                    sibling.loc.start
                );
            }
✓ Negative was executed (else)            }···
        }
Branch LogicalExpression
✓ Was returned            if (sibling.type === 'VariableDeclaration' && sibling.kind === node.kind) {
✓ Was returned            if (sibling.type === 'VariableDeclaration' && sibling.kind === node.kind) {
            if (sibling.type === 'VariableDeclaration' && sibling.kind === node.kind) {
                errors.add(
                    node.kind[0].toUpperCase() + node.kind.slice(1) + ' declarations should be joined',
                    sibling.loc.start
                );
            }
        }
    });
}
Function onevar
✓ Was calledfunction onevar(file, errors) {···
    file.iterateNodesByType(['Program', 'FunctionDeclaration', 'FunctionExpression'], function(node) {
        var firstVar = true;
        var firstConst = true;
        var firstParent = true;

        file.iterate(function(node) {
            var type = node.type;
            var kind = node.kind;

            // Don't go in nested scopes
            if (!firstParent && ['FunctionDeclaration', 'FunctionExpression'].indexOf(type) > -1) {
                return false;
            }

            if (firstParent) {
                firstParent = false;
            }

            if (type === 'VariableDeclaration') {
                if (kind === 'var') {
                    if (!firstVar) {
                        errors.add(
                            'Var declarations should be joined',
                            node.loc.start
                        );
                    } else {
                        firstVar = false;
                    }
                }

                if (kind === 'const') {
                    if (!firstConst) {
                        errors.add(
                            'Const declarations should be joined',
                            node.loc.start
                        );
                    } else {
                        firstConst = false;
                    }
                }
            }
        }, node);
    });
}
function onevar(file, errors) {
Function (anonymous_290)
✓ Was called    file.iterateNodesByType(['Program', 'FunctionDeclaration', 'FunctionExpression'], function(node) {···
        var firstVar = true;
        var firstConst = true;
        var firstParent = true;

        file.iterate(function(node) {
            var type = node.type;
            var kind = node.kind;

            // Don't go in nested scopes
            if (!firstParent && ['FunctionDeclaration', 'FunctionExpression'].indexOf(type) > -1) {
                return false;
            }

            if (firstParent) {
                firstParent = false;
            }

            if (type === 'VariableDeclaration') {
                if (kind === 'var') {
                    if (!firstVar) {
                        errors.add(
                            'Var declarations should be joined',
                            node.loc.start
                        );
                    } else {
                        firstVar = false;
                    }
                }

                if (kind === 'const') {
                    if (!firstConst) {
                        errors.add(
                            'Const declarations should be joined',
                            node.loc.start
                        );
                    } else {
                        firstConst = false;
                    }
                }
            }
        }, node);
    });
    file.iterateNodesByType(['Program', 'FunctionDeclaration', 'FunctionExpression'], function(node) {
        var firstVar = true;
        var firstConst = true;
        var firstParent = true;
Function (anonymous_291)
✓ Was called        file.iterate(function(node) {···
            var type = node.type;
            var kind = node.kind;

            // Don't go in nested scopes
            if (!firstParent && ['FunctionDeclaration', 'FunctionExpression'].indexOf(type) > -1) {
                return false;
            }

            if (firstParent) {
                firstParent = false;
            }

            if (type === 'VariableDeclaration') {
                if (kind === 'var') {
                    if (!firstVar) {
                        errors.add(
                            'Var declarations should be joined',
                            node.loc.start
                        );
                    } else {
                        firstVar = false;
                    }
                }

                if (kind === 'const') {
                    if (!firstConst) {
                        errors.add(
                            'Const declarations should be joined',
                            node.loc.start
                        );
                    } else {
                        firstConst = false;
                    }
                }
            }
        }, node);
        file.iterate(function(node) {
            var type = node.type;
            var kind = node.kind;
            // Don't go in nested scopes
Branch IfStatement
✓ Positive was executed (if)            if (!firstParent && ['FunctionDeclaration', 'FunctionExpression'].indexOf(type) > -1) {···
                return false;
            }
✓ Negative was executed (else)            }···

            if (firstParent) {
Branch LogicalExpression
✓ Was returned            if (!firstParent && ['FunctionDeclaration', 'FunctionExpression'].indexOf(type) > -1) {
✓ Was returned            if (!firstParent && ['FunctionDeclaration', 'FunctionExpression'].indexOf(type) > -1) {
            if (!firstParent && ['FunctionDeclaration', 'FunctionExpression'].indexOf(type) > -1) {
                return false;
            }
Branch IfStatement
✓ Positive was executed (if)            if (firstParent) {···
                firstParent = false;
            }
✓ Negative was executed (else)            }···

            if (type === 'VariableDeclaration') {
            if (firstParent) {
                firstParent = false;
            }
Branch IfStatement
✓ Positive was executed (if)            if (type === 'VariableDeclaration') {···
                if (kind === 'var') {
                    if (!firstVar) {
                        errors.add(
                            'Var declarations should be joined',
                            node.loc.start
                        );
                    } else {
                        firstVar = false;
                    }
                }

                if (kind === 'const') {
                    if (!firstConst) {
                        errors.add(
                            'Const declarations should be joined',
                            node.loc.start
                        );
                    } else {
                        firstConst = false;
                    }
                }
            }
✓ Negative was executed (else)            }···
        }, node);
            if (type === 'VariableDeclaration') {
Branch IfStatement
✓ Positive was executed (if)                if (kind === 'var') {···
                    if (!firstVar) {
                        errors.add(
                            'Var declarations should be joined',
                            node.loc.start
                        );
                    } else {
                        firstVar = false;
                    }
                }
✓ Negative was executed (else)                }···

                if (kind === 'const') {
                if (kind === 'var') {
Branch IfStatement
✓ Positive was executed (if)                    if (!firstVar) {···
                        errors.add(
                            'Var declarations should be joined',
                            node.loc.start
                        );
                    } else {
✓ Negative was executed (else)                    } else {···
                        firstVar = false;
                    }
                    if (!firstVar) {
                        errors.add(
                            'Var declarations should be joined',
                            node.loc.start
                        );
                    } else {
                        firstVar = false;
                    }
                }
Branch IfStatement
✓ Positive was executed (if)                if (kind === 'const') {···
                    if (!firstConst) {
                        errors.add(
                            'Const declarations should be joined',
                            node.loc.start
                        );
                    } else {
                        firstConst = false;
                    }
                }
✓ Negative was executed (else)                }···
            }
                if (kind === 'const') {
Branch IfStatement
✓ Positive was executed (if)                    if (!firstConst) {···
                        errors.add(
                            'Const declarations should be joined',
                            node.loc.start
                        );
                    } else {
✓ Negative was executed (else)                    } else {···
                        firstConst = false;
                    }
                    if (!firstConst) {
                        errors.add(
                            'Const declarations should be joined',
                            node.loc.start
                        );
                    } else {
                        firstConst = false;
                    }
                }
            }
        }, node);
    });
}
Function (anonymous_292)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_293)
✓ Was called    configure: function(options) {···
        assert(
            options === true || options === 'onevar',
            this.getOptionName() + ' option requires a true value or `onevar`'
        );

        this._check = typeof options === 'string' ? onevar : consecutive;
    },
    configure: function(options) {
        assert(
Branch LogicalExpression
✓ Was returned            options === true || options === 'onevar',
✓ Was returned            options === true || options === 'onevar',
            options === true || options === 'onevar',
            this.getOptionName() + ' option requires a true value or `onevar`'
        );
Branch ConditionalExpression
✓ Positive was returned (? ...)        this._check = typeof options === 'string' ? onevar : consecutive;
✓ Negative was returned (: ...)        this._check = typeof options === 'string' ? onevar : consecutive;
        this._check = typeof options === 'string' ? onevar : consecutive;
    },
Function (anonymous_294)
✓ Was called    getOptionName: function() {···
        return 'requireMultipleVarDecl';
    },
    getOptionName: function() {
        return 'requireMultipleVarDecl';
    },
Function (anonymous_295)
✓ Was called    check: function() {···
        return this._check.apply(this, arguments);
    }
    check: function() {
        return this._check.apply(this, arguments);
    }
};

disallow-multiple-var-decl.js
/**
 * Disallows multiple `var` declaration (except for-loop).
 *
 * Types: `Boolean` or `String`
 *
 * Values:
 *
 * - `true` disallows multiple variable declarations except within a for loop
 * - `'strict'` disallows all multiple variable declarations
 * - `'exceptUndefined'` allows declarations where all variables are not defined
 *
 * #### Example
 *
 * ```js
 * "disallowMultipleVarDecl": true
 * ```
 *
 * ##### Valid for `true`
 *
 * ```js
 * var x = 1;
 * var y = 2;
 *
 * for (var i = 0, j = arr.length; i < j; i++) {}
 * ```
 *
 * ##### Valid for `strict`
 *
 * ```js
 * var x = 1;
 * var y = 2;
 * ```
 *
 * ##### Valid for `exceptUndefined`
 *
 * ```js
 * var a, b;
 * var x = 1;
 * var y = 2;
 *
 * for (var i = 0, j = arr.length; i < j; i++) {}
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = 1,
 *     y = 2;
 *
 * var x, y = 2, z;
 * ```
 */
var assert = require('assert');
Function (anonymous_296)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_297)
✓ Was called    configure: function(options) {···
        assert(
            options === true ||
            options === 'strict' ||
            options === 'exceptUndefined',
            this.getOptionName() + ' option requires a true value, "strict", or "exceptUndefined"'
        );

        this.strictMode = options === 'strict';
        this.exceptUndefined = options === 'exceptUndefined';
    },
    configure: function(options) {
        assert(
Branch LogicalExpression
✓ Was returned            options === 'exceptUndefined',
✓ Was returned            options === true ||···
            options === 'strict' ||
Branch LogicalExpression
✓ Was returned            options === 'strict' ||
✓ Was returned            options === true ||
            options === true ||
            options === 'strict' ||
            options === 'exceptUndefined',
            this.getOptionName() + ' option requires a true value, "strict", or "exceptUndefined"'
        );
        this.strictMode = options === 'strict';
        this.exceptUndefined = options === 'exceptUndefined';
    },
Function (anonymous_298)
✓ Was called    getOptionName: function() {···
        return 'disallowMultipleVarDecl';
    },
    getOptionName: function() {
        return 'disallowMultipleVarDecl';
    },
Function (anonymous_299)
✓ Was called    check: function(file, errors) {···
        var inStrictMode = this.strictMode;
        var exceptUndefined = this.exceptUndefined;

        file.iterateNodesByType('VariableDeclaration', function(node) {
            var hasDefinedVariables = node.declarations.some(function(declaration) {
                return !!declaration.init;
            });

            var isForStatement = node.parentNode.type === 'ForStatement';

            // allow single var declarations
            if (node.declarations.length === 1 ||
                // allow multiple var declarations in for statement unless we're in strict mode
                // for (var i = 0, j = myArray.length; i < j; i++) {}
                !inStrictMode && isForStatement ||
                // allow multiple var declarations with all undefined variables in exceptUndefined mode
                // var a, b, c
                exceptUndefined && !hasDefinedVariables) {
                return;
            }

            errors.add('Multiple var declaration', node.loc.start);
        });
    }
    check: function(file, errors) {
        var inStrictMode = this.strictMode;
        var exceptUndefined = this.exceptUndefined;
Function (anonymous_300)
✓ Was called        file.iterateNodesByType('VariableDeclaration', function(node) {···
            var hasDefinedVariables = node.declarations.some(function(declaration) {
                return !!declaration.init;
            });

            var isForStatement = node.parentNode.type === 'ForStatement';

            // allow single var declarations
            if (node.declarations.length === 1 ||
                // allow multiple var declarations in for statement unless we're in strict mode
                // for (var i = 0, j = myArray.length; i < j; i++) {}
                !inStrictMode && isForStatement ||
                // allow multiple var declarations with all undefined variables in exceptUndefined mode
                // var a, b, c
                exceptUndefined && !hasDefinedVariables) {
                return;
            }

            errors.add('Multiple var declaration', node.loc.start);
        });
        file.iterateNodesByType('VariableDeclaration', function(node) {
Function (anonymous_301)
✓ Was called            var hasDefinedVariables = node.declarations.some(function(declaration) {···
                return !!declaration.init;
            });
            var hasDefinedVariables = node.declarations.some(function(declaration) {
                return !!declaration.init;
            });
            var isForStatement = node.parentNode.type === 'ForStatement';
            // allow single var declarations
Branch IfStatement
✓ Positive was executed (if)                exceptUndefined && !hasDefinedVariables) {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.add('Multiple var declaration', node.loc.start);
Branch LogicalExpression
✓ Was returned                exceptUndefined && !hasDefinedVariables) {
✓ Was returned            if (node.declarations.length === 1 ||···
                // allow multiple var declarations in for statement unless we're in strict mode
                // for (var i = 0, j = myArray.length; i < j; i++) {}
                !inStrictMode && isForStatement ||
Branch LogicalExpression
✓ Was returned                !inStrictMode && isForStatement ||
✓ Was returned            if (node.declarations.length === 1 ||
            if (node.declarations.length === 1 ||
                // allow multiple var declarations in for statement unless we're in strict mode
                // for (var i = 0, j = myArray.length; i < j; i++) {}
Branch LogicalExpression
✓ Was returned                !inStrictMode && isForStatement ||
✓ Was returned                !inStrictMode && isForStatement ||
                !inStrictMode && isForStatement ||
                // allow multiple var declarations with all undefined variables in exceptUndefined mode
                // var a, b, c
Branch LogicalExpression
✓ Was returned                exceptUndefined && !hasDefinedVariables) {
✓ Was returned                exceptUndefined && !hasDefinedVariables) {
                exceptUndefined && !hasDefinedVariables) {
                return;
            }
            errors.add('Multiple var declaration', node.loc.start);
        });
    }
};

disallow-empty-blocks.js
/**
 * Disallows empty blocks (except for catch blocks).
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * JSHint: [`noempty`](http://jshint.com/docs/options/#noempty)
 *
 * #### Example
 *
 * ```js
 * "disallowEmptyBlocks": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * if ( a == b ) { c = d; }
 * try { a = b; } catch( e ){}
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * if ( a == b ) { } else { c = d; }
 * ```
 */
var assert = require('assert');
Function (anonymous_302)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_303)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_304)
✓ Was called    getOptionName: function() {···
        return 'disallowEmptyBlocks';
    },
    getOptionName: function() {
        return 'disallowEmptyBlocks';
    },
Function (anonymous_305)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('BlockStatement', function(node) {
            if (node.body.length === 0 &&
                node.parentNode.type !== 'CatchClause' &&
                node.parentNode.type !== 'FunctionDeclaration' &&
                node.parentNode.type !== 'FunctionExpression') {
                errors.add('Empty block found', node.loc.end);
            }
        });
    }
    check: function(file, errors) {
Function (anonymous_306)
✓ Was called        file.iterateNodesByType('BlockStatement', function(node) {···
            if (node.body.length === 0 &&
                node.parentNode.type !== 'CatchClause' &&
                node.parentNode.type !== 'FunctionDeclaration' &&
                node.parentNode.type !== 'FunctionExpression') {
                errors.add('Empty block found', node.loc.end);
            }
        });
        file.iterateNodesByType('BlockStatement', function(node) {
Branch IfStatement
✓ Positive was executed (if)                node.parentNode.type !== 'FunctionExpression') {···
                errors.add('Empty block found', node.loc.end);
            }
✓ Negative was executed (else)            }···
        });
Branch LogicalExpression
✓ Was returned                node.parentNode.type !== 'FunctionExpression') {
✓ Was returned            if (node.body.length === 0 &&···
                node.parentNode.type !== 'CatchClause' &&
                node.parentNode.type !== 'FunctionDeclaration' &&
Branch LogicalExpression
✓ Was returned                node.parentNode.type !== 'FunctionDeclaration' &&
✓ Was returned            if (node.body.length === 0 &&···
                node.parentNode.type !== 'CatchClause' &&
Branch LogicalExpression
✓ Was returned                node.parentNode.type !== 'CatchClause' &&
✓ Was returned            if (node.body.length === 0 &&
            if (node.body.length === 0 &&
                node.parentNode.type !== 'CatchClause' &&
                node.parentNode.type !== 'FunctionDeclaration' &&
                node.parentNode.type !== 'FunctionExpression') {
                errors.add('Empty block found', node.loc.end);
            }
        });
    }
};

require-space-after-keywords.js
/**
 * Requires space after keyword.
 *
 * Types: `Array` or `Boolean`
 *
 * Values: Array of quoted keywords or `true` to require all of the keywords below to have a space afterward.
 *
 * #### Example
 *
 * ```js
 * "requireSpaceAfterKeywords": [
 *     "do",
 *     "for",
 *     "if",
 *     "else",
 *     "switch",
 *     "case",
 *     "try",
 *     "catch",
 *     "void",
 *     "while",
 *     "with",
 *     "return",
 *     "typeof",
 *     "function"
 * ]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * return true;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * if(x) {
 *     x++;
 * }
 * ```
 */
var assert = require('assert');
var defaultKeywords = require('../utils').spacedKeywords;
Function (anonymous_307)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_308)
✓ Was called    configure: function(keywords) {···
        assert(
            Array.isArray(keywords) || keywords === true,
            this.getOptionName() + ' option requires array or true value');

        if (keywords === true) {
            keywords = defaultKeywords;
        }

        this._keywords = keywords;
    },
    configure: function(keywords) {
        assert(
Branch LogicalExpression
✓ Was returned            Array.isArray(keywords) || keywords === true,
✓ Was returned            Array.isArray(keywords) || keywords === true,
            Array.isArray(keywords) || keywords === true,
            this.getOptionName() + ' option requires array or true value');
Branch IfStatement
✓ Positive was executed (if)        if (keywords === true) {···
            keywords = defaultKeywords;
        }
✓ Negative was executed (else)        }···

        this._keywords = keywords;
        if (keywords === true) {
            keywords = defaultKeywords;
        }
        this._keywords = keywords;
    },
Function (anonymous_309)
✓ Was called    getOptionName: function() {···
        return 'requireSpaceAfterKeywords';
    },
    getOptionName: function() {
        return 'requireSpaceAfterKeywords';
    },
Function (anonymous_310)
✓ Was called    check: function(file, errors) {···
        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {
            var nextToken = file.getNextToken(token, {includeComments: true});

            if (nextToken.type === 'Punctuator' && nextToken.value === ';') {
                return;
            }

            errors.assert.spacesBetween({
                token: token,
                nextToken: nextToken,
                exactly: 1,
                message: 'One space required after "' + token.value + '" keyword'
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_311)
✓ Was called        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {···
            var nextToken = file.getNextToken(token, {includeComments: true});

            if (nextToken.type === 'Punctuator' && nextToken.value === ';') {
                return;
            }

            errors.assert.spacesBetween({
                token: token,
                nextToken: nextToken,
                exactly: 1,
                message: 'One space required after "' + token.value + '" keyword'
            });
        });
        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {
            var nextToken = file.getNextToken(token, {includeComments: true});
Branch IfStatement
✓ Positive was executed (if)            if (nextToken.type === 'Punctuator' && nextToken.value === ';') {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.assert.spacesBetween({
Branch LogicalExpression
✓ Was returned            if (nextToken.type === 'Punctuator' && nextToken.value === ';') {
✓ Was returned            if (nextToken.type === 'Punctuator' && nextToken.value === ';') {
            if (nextToken.type === 'Punctuator' && nextToken.value === ';') {
                return;
            }
            errors.assert.spacesBetween({
                token: token,
                nextToken: nextToken,
                exactly: 1,
                message: 'One space required after "' + token.value + '" keyword'
            });
        });
    }
};

require-space-before-keywords.js
/**
 * Requires space before keyword.
 *
 * Types: `Array` or `Boolean`
 *
 * Values: Array of quoted keywords or `true` to require all possible keywords to have a preceding space.
 *
 * #### Example
 *
 * ```js
 * "requireSpaceBeforeKeywords": [
 *     "else",
 *     "while",
 *     "catch"
 * ]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * } else {
 *     x++;
 * }
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * }else {
 *     x++;
 * }
 * ```
 */
var assert = require('assert');
var defaultKeywords = require('../utils').spacedKeywords;
Function (anonymous_312)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_313)
✓ Was called    configure: function(keywords) {···
        assert(
            Array.isArray(keywords) || keywords === true,
            this.getOptionName() + ' option requires array or true value');

        if (keywords === true) {
            keywords = defaultKeywords;
        }

        this._keywords = keywords;
    },
    configure: function(keywords) {
        assert(
Branch LogicalExpression
✓ Was returned            Array.isArray(keywords) || keywords === true,
✓ Was returned            Array.isArray(keywords) || keywords === true,
            Array.isArray(keywords) || keywords === true,
            this.getOptionName() + ' option requires array or true value');
Branch IfStatement
✓ Positive was executed (if)        if (keywords === true) {···
            keywords = defaultKeywords;
        }
✓ Negative was executed (else)        }···

        this._keywords = keywords;
        if (keywords === true) {
            keywords = defaultKeywords;
        }
        this._keywords = keywords;
    },
Function (anonymous_314)
✓ Was called    getOptionName: function() {···
        return 'requireSpaceBeforeKeywords';
    },
    getOptionName: function() {
        return 'requireSpaceBeforeKeywords';
    },
Function (anonymous_315)
✓ Was called    check: function(file, errors) {···
        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {
            var prevToken = file.getPrevToken(token, {includeComments: true});
            if (!prevToken || prevToken.isComment) {
                return;
            }

            if (prevToken.type !== 'Punctuator' || prevToken.value !== ';') {
                errors.assert.whitespaceBetween({
                    token: prevToken,
                    nextToken: token,
                    message: 'Missing space before "' + token.value + '" keyword'
                });
            }
        });
    }
    check: function(file, errors) {
Function (anonymous_316)
✓ Was called        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {···
            var prevToken = file.getPrevToken(token, {includeComments: true});
            if (!prevToken || prevToken.isComment) {
                return;
            }

            if (prevToken.type !== 'Punctuator' || prevToken.value !== ';') {
                errors.assert.whitespaceBetween({
                    token: prevToken,
                    nextToken: token,
                    message: 'Missing space before "' + token.value + '" keyword'
                });
            }
        });
        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {
            var prevToken = file.getPrevToken(token, {includeComments: true});
Branch IfStatement
✓ Positive was executed (if)            if (!prevToken || prevToken.isComment) {···
                return;
            }
✓ Negative was executed (else)            }···

            if (prevToken.type !== 'Punctuator' || prevToken.value !== ';') {
Branch LogicalExpression
✓ Was returned            if (!prevToken || prevToken.isComment) {
✓ Was returned            if (!prevToken || prevToken.isComment) {
            if (!prevToken || prevToken.isComment) {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (prevToken.type !== 'Punctuator' || prevToken.value !== ';') {···
                errors.assert.whitespaceBetween({
                    token: prevToken,
                    nextToken: token,
                    message: 'Missing space before "' + token.value + '" keyword'
                });
            }
✓ Negative was executed (else)            }···
        });
Branch LogicalExpression
✓ Was returned            if (prevToken.type !== 'Punctuator' || prevToken.value !== ';') {
✗ Was not returned            if (prevToken.type !== 'Punctuator' || prevToken.value !== ';') {
            if (prevToken.type !== 'Punctuator' || prevToken.value !== ';') {
                errors.assert.whitespaceBetween({
                    token: prevToken,
                    nextToken: token,
                    message: 'Missing space before "' + token.value + '" keyword'
                });
            }
        });
    }
};

disallow-space-after-keywords.js
/**
 * Disallows space after keyword.
 *
 * Types: `Array` or `Boolean`
 *
 * Values: Array of quoted keywords or `true` to disallow spaces after all possible keywords.
 *
 * #### Example
 *
 * ```js
 * "disallowSpaceAfterKeywords": [
 *     "if",
 *     "else",
 *     "for",
 *     "while",
 *     "do",
 *     "switch",
 *     "try",
 *     "catch"
 * ]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * if(x > y) {
 *     y++;
 * }
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * if (x > y) {
 *     y++;
 * }
 * ```
 */
var assert = require('assert');
var defaultKeywords = require('../utils').spacedKeywords;
Function (anonymous_317)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_318)
✓ Was called    configure: function(keywords) {···
        assert(
            Array.isArray(keywords) || keywords === true,
            this.getOptionName() + ' option requires array or true value'
        );

        if (keywords === true) {
            keywords = defaultKeywords;
        }

        this._keywords = keywords;
    },
    configure: function(keywords) {
        assert(
Branch LogicalExpression
✓ Was returned            Array.isArray(keywords) || keywords === true,
✓ Was returned            Array.isArray(keywords) || keywords === true,
            Array.isArray(keywords) || keywords === true,
            this.getOptionName() + ' option requires array or true value'
        );
Branch IfStatement
✓ Positive was executed (if)        if (keywords === true) {···
            keywords = defaultKeywords;
        }
✓ Negative was executed (else)        }···

        this._keywords = keywords;
        if (keywords === true) {
            keywords = defaultKeywords;
        }
        this._keywords = keywords;
    },
Function (anonymous_319)
✓ Was called    getOptionName: function() {···
        return 'disallowSpaceAfterKeywords';
    },
    getOptionName: function() {
        return 'disallowSpaceAfterKeywords';
    },
Function (anonymous_320)
✓ Was called    check: function(file, errors) {···
        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {
            errors.assert.noWhitespaceBetween({
                token: token,
                nextToken: file.getNextToken(token)
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_321)
✓ Was called        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {···
            errors.assert.noWhitespaceBetween({
                token: token,
                nextToken: file.getNextToken(token)
            });
        });
        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {
            errors.assert.noWhitespaceBetween({
                token: token,
                nextToken: file.getNextToken(token)
            });
        });
    }
};

disallow-space-before-keywords.js
/**
 * Disallows space before keyword.
 *
 * Types: `Array` or `Boolean`
 *
 * Values: Array of quoted keywords or `true` to disallow spaces before all possible keywords.
 *
 * #### Example
 *
 * ```js
 * "disallowSpaceBeforeKeywords": [
 *     "else",
 *     "catch"
 * ]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * }else {
 *     y--;
 * }
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * } else {
 *     y--;
 * }
 * ```
 */
var assert = require('assert');
var defaultKeywords = require('../utils').spacedKeywords;
Function (anonymous_322)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_323)
✓ Was called    configure: function(keywords) {···
        assert(
            Array.isArray(keywords) || keywords === true,
            this.getOptionName() + ' option requires array or true value');

        if (keywords === true) {
            keywords = defaultKeywords;
        }

        this._keywords = keywords;
    },
    configure: function(keywords) {
        assert(
Branch LogicalExpression
✓ Was returned            Array.isArray(keywords) || keywords === true,
✓ Was returned            Array.isArray(keywords) || keywords === true,
            Array.isArray(keywords) || keywords === true,
            this.getOptionName() + ' option requires array or true value');
Branch IfStatement
✓ Positive was executed (if)        if (keywords === true) {···
            keywords = defaultKeywords;
        }
✓ Negative was executed (else)        }···

        this._keywords = keywords;
        if (keywords === true) {
            keywords = defaultKeywords;
        }
        this._keywords = keywords;
    },
Function (anonymous_324)
✓ Was called    getOptionName: function() {···
        return 'disallowSpaceBeforeKeywords';
    },
    getOptionName: function() {
        return 'disallowSpaceBeforeKeywords';
    },
Function (anonymous_325)
✓ Was called    check: function(file, errors) {···
        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {
            var prevToken = file.getPrevToken(token, {includeComments: true});
            if (!prevToken || prevToken.isComment) {
                return;
            }

            if (prevToken.type !== 'Keyword' && prevToken.value !== ';') {
                errors.assert.noWhitespaceBetween({
                    token: prevToken,
                    nextToken: token,
                    message: 'Illegal space before "' + token.value + '" keyword'
                });
            }
        });
    }
    check: function(file, errors) {
Function (anonymous_326)
✓ Was called        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {···
            var prevToken = file.getPrevToken(token, {includeComments: true});
            if (!prevToken || prevToken.isComment) {
                return;
            }

            if (prevToken.type !== 'Keyword' && prevToken.value !== ';') {
                errors.assert.noWhitespaceBetween({
                    token: prevToken,
                    nextToken: token,
                    message: 'Illegal space before "' + token.value + '" keyword'
                });
            }
        });
        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {
            var prevToken = file.getPrevToken(token, {includeComments: true});
Branch IfStatement
✓ Positive was executed (if)            if (!prevToken || prevToken.isComment) {···
                return;
            }
✓ Negative was executed (else)            }···

            if (prevToken.type !== 'Keyword' && prevToken.value !== ';') {
Branch LogicalExpression
✓ Was returned            if (!prevToken || prevToken.isComment) {
✓ Was returned            if (!prevToken || prevToken.isComment) {
            if (!prevToken || prevToken.isComment) {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (prevToken.type !== 'Keyword' && prevToken.value !== ';') {···
                errors.assert.noWhitespaceBetween({
                    token: prevToken,
                    nextToken: token,
                    message: 'Illegal space before "' + token.value + '" keyword'
                });
            }
✓ Negative was executed (else)            }···
        });
Branch LogicalExpression
✓ Was returned            if (prevToken.type !== 'Keyword' && prevToken.value !== ';') {
✓ Was returned            if (prevToken.type !== 'Keyword' && prevToken.value !== ';') {
            if (prevToken.type !== 'Keyword' && prevToken.value !== ';') {
                errors.assert.noWhitespaceBetween({
                    token: prevToken,
                    nextToken: token,
                    message: 'Illegal space before "' + token.value + '" keyword'
                });
            }
        });
    }
};

require-parentheses-around-iife.js
/**
 * Requires parentheses around immediately invoked function expressions.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * JSHint: [`immed`](http://www.jshint.com/docs/options/#immed)
 *
 * #### Example
 *
 * ```js
 * "requireParenthesesAroundIIFE": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var a = (function(){ return 1; })();
 * var b = (function(){ return 2; }());
 * var c = (function(){ return 3; }).call(this, arg1);
 * var d = (function(){ return 3; }.call(this, arg1));
 * var e = (function(){ return d; }).apply(this, args);
 * var f = (function(){ return d; }.apply(this, args));
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var a = function(){ return 1; }();
 * var c = function(){ return 3; }.call(this, arg1);
 * var d = function(){ return d; }.apply(this, args);
 * ```
 */
var assert = require('assert');
var utils = require('../utils');
Function (anonymous_327)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_328)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_329)
✓ Was called    getOptionName: function() {···
        return 'requireParenthesesAroundIIFE';
    },
    getOptionName: function() {
        return 'requireParenthesesAroundIIFE';
    },
Function (anonymous_330)
✓ Was called    check: function(file, errors) {···

        function isWrapped(node) {
            var openParensToken = file.getPrevToken(file.getFirstNodeToken(node));

            var closingParensToken = file.getNextToken(file.getLastNodeToken(node));
            var closingTokenValue = closingParensToken ? closingParensToken.value : '';

            return openParensToken.value + closingTokenValue === '()';
        }

        file.iterateNodesByType('CallExpression', function(node) {
            var inner = utils.getFunctionNodeFromIIFE(node);

            if (inner && !isWrapped(inner) && !isWrapped(node)) {
                errors.add(
                    'Wrap immediately invoked function expressions in parentheses',
                    node.loc.start.line,
                    node.loc.start.column
                );

            }
        });
    }
    check: function(file, errors) {
Function isWrapped
✓ Was called        function isWrapped(node) {···
            var openParensToken = file.getPrevToken(file.getFirstNodeToken(node));

            var closingParensToken = file.getNextToken(file.getLastNodeToken(node));
            var closingTokenValue = closingParensToken ? closingParensToken.value : '';

            return openParensToken.value + closingTokenValue === '()';
        }
        function isWrapped(node) {
            var openParensToken = file.getPrevToken(file.getFirstNodeToken(node));
            var closingParensToken = file.getNextToken(file.getLastNodeToken(node));
Branch ConditionalExpression
✓ Positive was returned (? ...)            var closingTokenValue = closingParensToken ? closingParensToken.value : '';
✗ Negative was not returned (: ...)            var closingTokenValue = closingParensToken ? closingParensToken.value : '';
            var closingTokenValue = closingParensToken ? closingParensToken.value : '';
            return openParensToken.value + closingTokenValue === '()';
        }
Function (anonymous_332)
✓ Was called        file.iterateNodesByType('CallExpression', function(node) {···
            var inner = utils.getFunctionNodeFromIIFE(node);

            if (inner && !isWrapped(inner) && !isWrapped(node)) {
                errors.add(
                    'Wrap immediately invoked function expressions in parentheses',
                    node.loc.start.line,
                    node.loc.start.column
                );

            }
        });
        file.iterateNodesByType('CallExpression', function(node) {
            var inner = utils.getFunctionNodeFromIIFE(node);
Branch IfStatement
✓ Positive was executed (if)            if (inner && !isWrapped(inner) && !isWrapped(node)) {···
                errors.add(
                    'Wrap immediately invoked function expressions in parentheses',
                    node.loc.start.line,
                    node.loc.start.column
                );

            }
✓ Negative was executed (else)            }···
        });
Branch LogicalExpression
✓ Was returned            if (inner && !isWrapped(inner) && !isWrapped(node)) {
✓ Was returned            if (inner && !isWrapped(inner) && !isWrapped(node)) {
Branch LogicalExpression
✓ Was returned            if (inner && !isWrapped(inner) && !isWrapped(node)) {
✓ Was returned            if (inner && !isWrapped(inner) && !isWrapped(node)) {
            if (inner && !isWrapped(inner) && !isWrapped(node)) {
                errors.add(
                    'Wrap immediately invoked function expressions in parentheses',
                    node.loc.start.line,
                    node.loc.start.column
                );
            }
        });
    }
};

require-left-sticked-operators.js
Function (anonymous_333)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_334)
✓ Was called    configure: function() {},
    configure: function() {},
Function (anonymous_335)
✓ Was called    getOptionName: function() {···
        return 'requireLeftStickedOperators';
    },
    getOptionName: function() {
        return 'requireLeftStickedOperators';
    },
Function (anonymous_336)
✓ Was called    check: function(file, errors) {···
        errors.add(
            'The requireLeftStickedOperators rule is no longer supported.' +
            '\nPlease use the following rules instead:' +
            '\n' +
            '\ndisallowSpaceBeforeBinaryOperators' +
            '\ndisallowSpaceBeforePostfixUnaryOperators' +
            '\ndisallowSpacesInConditionalExpression',
            1,
            0
        );
    }
    check: function(file, errors) {
        errors.add(
            'The requireLeftStickedOperators rule is no longer supported.' +
            '\nPlease use the following rules instead:' +
            '\n' +
            '\ndisallowSpaceBeforeBinaryOperators' +
            '\ndisallowSpaceBeforePostfixUnaryOperators' +
            '\ndisallowSpacesInConditionalExpression',
            1,
            0
        );
    }
};

disallow-left-sticked-operators.js
Function (anonymous_337)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_338)
✓ Was called    configure: function() {},
    configure: function() {},
Function (anonymous_339)
✓ Was called    getOptionName: function() {···
        return 'disallowLeftStickedOperators';
    },
    getOptionName: function() {
        return 'disallowLeftStickedOperators';
    },
Function (anonymous_340)
✓ Was called    check: function(file, errors) {···
        errors.add(
            'The disallowLeftStickedOperators rule is no longer supported.' +
            '\nPlease use the following rules instead:' +
            '\n' +
            '\nrequireSpaceBeforeBinaryOperators' +
            '\nrequireSpaceBeforePostfixUnaryOperators' +
            '\nrequireSpacesInConditionalExpression',
            1,
            0
        );
    }
    check: function(file, errors) {
        errors.add(
            'The disallowLeftStickedOperators rule is no longer supported.' +
            '\nPlease use the following rules instead:' +
            '\n' +
            '\nrequireSpaceBeforeBinaryOperators' +
            '\nrequireSpaceBeforePostfixUnaryOperators' +
            '\nrequireSpacesInConditionalExpression',
            1,
            0
        );
    }
};

require-right-sticked-operators.js
Function (anonymous_341)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_342)
✓ Was called    configure: function() {},
    configure: function() {},
Function (anonymous_343)
✓ Was called    getOptionName: function() {···
        return 'requireRightStickedOperators';
    },
    getOptionName: function() {
        return 'requireRightStickedOperators';
    },
Function (anonymous_344)
✓ Was called    check: function(file, errors) {···
        errors.add(
            'The requireRightStickedOperators rule is no longer supported.' +
            '\nPlease use the following rules instead:' +
            '\n' +
            '\ndisallowSpaceAfterBinaryOperators' +
            '\ndisallowSpaceAfterPrefixUnaryOperators' +
            '\ndisallowSpacesInConditionalExpression',
            1,
            0
        );
    }
    check: function(file, errors) {
        errors.add(
            'The requireRightStickedOperators rule is no longer supported.' +
            '\nPlease use the following rules instead:' +
            '\n' +
            '\ndisallowSpaceAfterBinaryOperators' +
            '\ndisallowSpaceAfterPrefixUnaryOperators' +
            '\ndisallowSpacesInConditionalExpression',
            1,
            0
        );
    }
};

disallow-right-sticked-operators.js
Function (anonymous_345)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_346)
✓ Was called    configure: function() {},
    configure: function() {},
Function (anonymous_347)
✓ Was called    getOptionName: function() {···
        return 'disallowRightStickedOperators';
    },
    getOptionName: function() {
        return 'disallowRightStickedOperators';
    },
Function (anonymous_348)
✓ Was called    check: function(file, errors) {···
        errors.add(
            'The disallowRightStickedOperators rule is no longer supported.' +
            '\nPlease use the following rules instead:' +
            '\n' +
            '\nrequireSpaceAfterBinaryOperators' +
            '\nrequireSpaceAfterPrefixUnaryOperators' +
            '\nrequireSpacesInConditionalExpression',
            1,
            0
        );
    }
    check: function(file, errors) {
        errors.add(
            'The disallowRightStickedOperators rule is no longer supported.' +
            '\nPlease use the following rules instead:' +
            '\n' +
            '\nrequireSpaceAfterBinaryOperators' +
            '\nrequireSpaceAfterPrefixUnaryOperators' +
            '\nrequireSpacesInConditionalExpression',
            1,
            0
        );
    }
};

validate-jsdoc.js
var assert = require('assert');
Function (anonymous_349)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_350)
✓ Was called    configure: function(options) {···
        assert(typeof options === 'object', this.getOptionName() + ' option requires object value');
        this._options = options;
    },
    configure: function(options) {
        assert(typeof options === 'object', this.getOptionName() + ' option requires object value');
        this._options = options;
    },
Function (anonymous_351)
✓ Was called    getOptionName: function() {···
        return 'validateJSDoc';
    },
    getOptionName: function() {
        return 'validateJSDoc';
    },
Function (anonymous_352)
✓ Was called    check: function(file, errors) {···
        var options = this._options;
        var comments = file.getComments();
        file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {
            var jsDoc = getJsDocForLine(node.loc.start.line);
            if (jsDoc) {
                var jsDocData = jsDoc.value;
                var jsDocLines = jsDocData.split('\n');
                var paramIndex = 0;
                if (options.checkParamNames || options.checkRedundantParams || options.requireParamTypes) {
                    for (var i = 0, l = jsDocLines.length; i < l; i++) {
                        var line = jsDocLines[i].trim();
                        if (line.charAt(0) === '*') {
                            line = line.substr(1).trim();
                            if (line.indexOf('@param') === 0) {
                                var match = line.match(/^@param\s+(?:{(.+?)})?\s*(?:\[)?([a-zA-Z0-9_\.\$]+)/);
                                if (match) {
                                    var jsDocParamType = match[1];
                                    var jsDocParamName = match[2];
                                    if (options.requireParamTypes && !jsDocParamType) {
                                        errors.add(
                                            'Missing JSDoc @param type',
                                            jsDoc.loc.start.line + i,
                                            jsDocLines[i].indexOf('@param')
                                        );
                                    }
                                    if (jsDocParamName.indexOf('.') === -1) {
                                        var param = node.params[paramIndex];
                                        if (param) {
                                            if (jsDocParamName !== param.name) {
                                                if (options.checkParamNames) {
                                                    errors.add(
                                                        'Invalid JSDoc @param argument name',
                                                        jsDoc.loc.start.line + i,
                                                        jsDocLines[i].indexOf('@param')
                                                    );
                                                }
                                            }
                                        } else {
                                            if (options.checkRedundantParams) {
                                                errors.add(
                                                    'Redundant JSDoc @param',
                                                    jsDoc.loc.start.line + i,
                                                    jsDocLines[i].indexOf('@param')
                                                );
                                            }
                                        }
                                        paramIndex++;
                                    }
                                } else {
                                    errors.add(
                                        'Invalid JSDoc @param',
                                        jsDoc.loc.start.line + i,
                                        jsDocLines[i].indexOf('@param')
                                    );
                                }
                            }
                        }
                    }
                }
            }
        });

        function getJsDocForLine(line) {
            line--;
            for (var i = 0, l = comments.length; i < l; i++) {
                var comment = comments[i];
                if (comment.loc.end.line === line && comment.type === 'Block' && comment.value.charAt(0) === '*') {
                    return comment;
                }
            }
            return null;
        }
    }
    check: function(file, errors) {
        var options = this._options;
        var comments = file.getComments();
Function (anonymous_353)
✓ Was called        file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {···
            var jsDoc = getJsDocForLine(node.loc.start.line);
            if (jsDoc) {
                var jsDocData = jsDoc.value;
                var jsDocLines = jsDocData.split('\n');
                var paramIndex = 0;
                if (options.checkParamNames || options.checkRedundantParams || options.requireParamTypes) {
                    for (var i = 0, l = jsDocLines.length; i < l; i++) {
                        var line = jsDocLines[i].trim();
                        if (line.charAt(0) === '*') {
                            line = line.substr(1).trim();
                            if (line.indexOf('@param') === 0) {
                                var match = line.match(/^@param\s+(?:{(.+?)})?\s*(?:\[)?([a-zA-Z0-9_\.\$]+)/);
                                if (match) {
                                    var jsDocParamType = match[1];
                                    var jsDocParamName = match[2];
                                    if (options.requireParamTypes && !jsDocParamType) {
                                        errors.add(
                                            'Missing JSDoc @param type',
                                            jsDoc.loc.start.line + i,
                                            jsDocLines[i].indexOf('@param')
                                        );
                                    }
                                    if (jsDocParamName.indexOf('.') === -1) {
                                        var param = node.params[paramIndex];
                                        if (param) {
                                            if (jsDocParamName !== param.name) {
                                                if (options.checkParamNames) {
                                                    errors.add(
                                                        'Invalid JSDoc @param argument name',
                                                        jsDoc.loc.start.line + i,
                                                        jsDocLines[i].indexOf('@param')
                                                    );
                                                }
                                            }
                                        } else {
                                            if (options.checkRedundantParams) {
                                                errors.add(
                                                    'Redundant JSDoc @param',
                                                    jsDoc.loc.start.line + i,
                                                    jsDocLines[i].indexOf('@param')
                                                );
                                            }
                                        }
                                        paramIndex++;
                                    }
                                } else {
                                    errors.add(
                                        'Invalid JSDoc @param',
                                        jsDoc.loc.start.line + i,
                                        jsDocLines[i].indexOf('@param')
                                    );
                                }
                            }
                        }
                    }
                }
            }
        });
        file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {
            var jsDoc = getJsDocForLine(node.loc.start.line);
Branch IfStatement
✓ Positive was executed (if)            if (jsDoc) {···
                var jsDocData = jsDoc.value;
                var jsDocLines = jsDocData.split('\n');
                var paramIndex = 0;
                if (options.checkParamNames || options.checkRedundantParams || options.requireParamTypes) {
                    for (var i = 0, l = jsDocLines.length; i < l; i++) {
                        var line = jsDocLines[i].trim();
                        if (line.charAt(0) === '*') {
                            line = line.substr(1).trim();
                            if (line.indexOf('@param') === 0) {
                                var match = line.match(/^@param\s+(?:{(.+?)})?\s*(?:\[)?([a-zA-Z0-9_\.\$]+)/);
                                if (match) {
                                    var jsDocParamType = match[1];
                                    var jsDocParamName = match[2];
                                    if (options.requireParamTypes && !jsDocParamType) {
                                        errors.add(
                                            'Missing JSDoc @param type',
                                            jsDoc.loc.start.line + i,
                                            jsDocLines[i].indexOf('@param')
                                        );
                                    }
                                    if (jsDocParamName.indexOf('.') === -1) {
                                        var param = node.params[paramIndex];
                                        if (param) {
                                            if (jsDocParamName !== param.name) {
                                                if (options.checkParamNames) {
                                                    errors.add(
                                                        'Invalid JSDoc @param argument name',
                                                        jsDoc.loc.start.line + i,
                                                        jsDocLines[i].indexOf('@param')
                                                    );
                                                }
                                            }
                                        } else {
                                            if (options.checkRedundantParams) {
                                                errors.add(
                                                    'Redundant JSDoc @param',
                                                    jsDoc.loc.start.line + i,
                                                    jsDocLines[i].indexOf('@param')
                                                );
                                            }
                                        }
                                        paramIndex++;
                                    }
                                } else {
                                    errors.add(
                                        'Invalid JSDoc @param',
                                        jsDoc.loc.start.line + i,
                                        jsDocLines[i].indexOf('@param')
                                    );
                                }
                            }
                        }
                    }
                }
            }
✓ Negative was executed (else)            }···
        });
            if (jsDoc) {
                var jsDocData = jsDoc.value;
                var jsDocLines = jsDocData.split('\n');
                var paramIndex = 0;
Branch IfStatement
✓ Positive was executed (if)                if (options.checkParamNames || options.checkRedundantParams || options.requireParamTypes) {···
                    for (var i = 0, l = jsDocLines.length; i < l; i++) {
                        var line = jsDocLines[i].trim();
                        if (line.charAt(0) === '*') {
                            line = line.substr(1).trim();
                            if (line.indexOf('@param') === 0) {
                                var match = line.match(/^@param\s+(?:{(.+?)})?\s*(?:\[)?([a-zA-Z0-9_\.\$]+)/);
                                if (match) {
                                    var jsDocParamType = match[1];
                                    var jsDocParamName = match[2];
                                    if (options.requireParamTypes && !jsDocParamType) {
                                        errors.add(
                                            'Missing JSDoc @param type',
                                            jsDoc.loc.start.line + i,
                                            jsDocLines[i].indexOf('@param')
                                        );
                                    }
                                    if (jsDocParamName.indexOf('.') === -1) {
                                        var param = node.params[paramIndex];
                                        if (param) {
                                            if (jsDocParamName !== param.name) {
                                                if (options.checkParamNames) {
                                                    errors.add(
                                                        'Invalid JSDoc @param argument name',
                                                        jsDoc.loc.start.line + i,
                                                        jsDocLines[i].indexOf('@param')
                                                    );
                                                }
                                            }
                                        } else {
                                            if (options.checkRedundantParams) {
                                                errors.add(
                                                    'Redundant JSDoc @param',
                                                    jsDoc.loc.start.line + i,
                                                    jsDocLines[i].indexOf('@param')
                                                );
                                            }
                                        }
                                        paramIndex++;
                                    }
                                } else {
                                    errors.add(
                                        'Invalid JSDoc @param',
                                        jsDoc.loc.start.line + i,
                                        jsDocLines[i].indexOf('@param')
                                    );
                                }
                            }
                        }
                    }
                }
✓ Negative was executed (else)                }···
            }
Branch LogicalExpression
✓ Was returned                if (options.checkParamNames || options.checkRedundantParams || options.requireParamTypes) {
✓ Was returned                if (options.checkParamNames || options.checkRedundantParams || options.requireParamTypes) {
Branch LogicalExpression
✓ Was returned                if (options.checkParamNames || options.checkRedundantParams || options.requireParamTypes) {
✓ Was returned                if (options.checkParamNames || options.checkRedundantParams || options.requireParamTypes) {
                if (options.checkParamNames || options.checkRedundantParams || options.requireParamTypes) {
                    for (var i = 0, l = jsDocLines.length; i < l; i++) {
                        var line = jsDocLines[i].trim();
Branch IfStatement
✓ Positive was executed (if)                        if (line.charAt(0) === '*') {···
                            line = line.substr(1).trim();
                            if (line.indexOf('@param') === 0) {
                                var match = line.match(/^@param\s+(?:{(.+?)})?\s*(?:\[)?([a-zA-Z0-9_\.\$]+)/);
                                if (match) {
                                    var jsDocParamType = match[1];
                                    var jsDocParamName = match[2];
                                    if (options.requireParamTypes && !jsDocParamType) {
                                        errors.add(
                                            'Missing JSDoc @param type',
                                            jsDoc.loc.start.line + i,
                                            jsDocLines[i].indexOf('@param')
                                        );
                                    }
                                    if (jsDocParamName.indexOf('.') === -1) {
                                        var param = node.params[paramIndex];
                                        if (param) {
                                            if (jsDocParamName !== param.name) {
                                                if (options.checkParamNames) {
                                                    errors.add(
                                                        'Invalid JSDoc @param argument name',
                                                        jsDoc.loc.start.line + i,
                                                        jsDocLines[i].indexOf('@param')
                                                    );
                                                }
                                            }
                                        } else {
                                            if (options.checkRedundantParams) {
                                                errors.add(
                                                    'Redundant JSDoc @param',
                                                    jsDoc.loc.start.line + i,
                                                    jsDocLines[i].indexOf('@param')
                                                );
                                            }
                                        }
                                        paramIndex++;
                                    }
                                } else {
                                    errors.add(
                                        'Invalid JSDoc @param',
                                        jsDoc.loc.start.line + i,
                                        jsDocLines[i].indexOf('@param')
                                    );
                                }
                            }
                        }
✓ Negative was executed (else)                        }···
                    }
                        if (line.charAt(0) === '*') {
                            line = line.substr(1).trim();
Branch IfStatement
✓ Positive was executed (if)                            if (line.indexOf('@param') === 0) {···
                                var match = line.match(/^@param\s+(?:{(.+?)})?\s*(?:\[)?([a-zA-Z0-9_\.\$]+)/);
                                if (match) {
                                    var jsDocParamType = match[1];
                                    var jsDocParamName = match[2];
                                    if (options.requireParamTypes && !jsDocParamType) {
                                        errors.add(
                                            'Missing JSDoc @param type',
                                            jsDoc.loc.start.line + i,
                                            jsDocLines[i].indexOf('@param')
                                        );
                                    }
                                    if (jsDocParamName.indexOf('.') === -1) {
                                        var param = node.params[paramIndex];
                                        if (param) {
                                            if (jsDocParamName !== param.name) {
                                                if (options.checkParamNames) {
                                                    errors.add(
                                                        'Invalid JSDoc @param argument name',
                                                        jsDoc.loc.start.line + i,
                                                        jsDocLines[i].indexOf('@param')
                                                    );
                                                }
                                            }
                                        } else {
                                            if (options.checkRedundantParams) {
                                                errors.add(
                                                    'Redundant JSDoc @param',
                                                    jsDoc.loc.start.line + i,
                                                    jsDocLines[i].indexOf('@param')
                                                );
                                            }
                                        }
                                        paramIndex++;
                                    }
                                } else {
                                    errors.add(
                                        'Invalid JSDoc @param',
                                        jsDoc.loc.start.line + i,
                                        jsDocLines[i].indexOf('@param')
                                    );
                                }
                            }
✓ Negative was executed (else)                            }···
                        }
                            if (line.indexOf('@param') === 0) {
                                var match = line.match(/^@param\s+(?:{(.+?)})?\s*(?:\[)?([a-zA-Z0-9_\.\$]+)/);
Branch IfStatement
✓ Positive was executed (if)                                if (match) {···
                                    var jsDocParamType = match[1];
                                    var jsDocParamName = match[2];
                                    if (options.requireParamTypes && !jsDocParamType) {
                                        errors.add(
                                            'Missing JSDoc @param type',
                                            jsDoc.loc.start.line + i,
                                            jsDocLines[i].indexOf('@param')
                                        );
                                    }
                                    if (jsDocParamName.indexOf('.') === -1) {
                                        var param = node.params[paramIndex];
                                        if (param) {
                                            if (jsDocParamName !== param.name) {
                                                if (options.checkParamNames) {
                                                    errors.add(
                                                        'Invalid JSDoc @param argument name',
                                                        jsDoc.loc.start.line + i,
                                                        jsDocLines[i].indexOf('@param')
                                                    );
                                                }
                                            }
                                        } else {
                                            if (options.checkRedundantParams) {
                                                errors.add(
                                                    'Redundant JSDoc @param',
                                                    jsDoc.loc.start.line + i,
                                                    jsDocLines[i].indexOf('@param')
                                                );
                                            }
                                        }
                                        paramIndex++;
                                    }
                                } else {
✓ Negative was executed (else)                                } else {···
                                    errors.add(
                                        'Invalid JSDoc @param',
                                        jsDoc.loc.start.line + i,
                                        jsDocLines[i].indexOf('@param')
                                    );
                                }
                                if (match) {
                                    var jsDocParamType = match[1];
                                    var jsDocParamName = match[2];
Branch IfStatement
✓ Positive was executed (if)                                    if (options.requireParamTypes && !jsDocParamType) {···
                                        errors.add(
                                            'Missing JSDoc @param type',
                                            jsDoc.loc.start.line + i,
                                            jsDocLines[i].indexOf('@param')
                                        );
                                    }
✓ Negative was executed (else)                                    }···
                                    if (jsDocParamName.indexOf('.') === -1) {
Branch LogicalExpression
✓ Was returned                                    if (options.requireParamTypes && !jsDocParamType) {
✓ Was returned                                    if (options.requireParamTypes && !jsDocParamType) {
                                    if (options.requireParamTypes && !jsDocParamType) {
                                        errors.add(
                                            'Missing JSDoc @param type',
                                            jsDoc.loc.start.line + i,
                                            jsDocLines[i].indexOf('@param')
                                        );
                                    }
Branch IfStatement
✓ Positive was executed (if)                                    if (jsDocParamName.indexOf('.') === -1) {···
                                        var param = node.params[paramIndex];
                                        if (param) {
                                            if (jsDocParamName !== param.name) {
                                                if (options.checkParamNames) {
                                                    errors.add(
                                                        'Invalid JSDoc @param argument name',
                                                        jsDoc.loc.start.line + i,
                                                        jsDocLines[i].indexOf('@param')
                                                    );
                                                }
                                            }
                                        } else {
                                            if (options.checkRedundantParams) {
                                                errors.add(
                                                    'Redundant JSDoc @param',
                                                    jsDoc.loc.start.line + i,
                                                    jsDocLines[i].indexOf('@param')
                                                );
                                            }
                                        }
                                        paramIndex++;
                                    }
✓ Negative was executed (else)                                    }···
                                } else {
                                    if (jsDocParamName.indexOf('.') === -1) {
                                        var param = node.params[paramIndex];
Branch IfStatement
✓ Positive was executed (if)                                        if (param) {···
                                            if (jsDocParamName !== param.name) {
                                                if (options.checkParamNames) {
                                                    errors.add(
                                                        'Invalid JSDoc @param argument name',
                                                        jsDoc.loc.start.line + i,
                                                        jsDocLines[i].indexOf('@param')
                                                    );
                                                }
                                            }
                                        } else {
✓ Negative was executed (else)                                        } else {···
                                            if (options.checkRedundantParams) {
                                                errors.add(
                                                    'Redundant JSDoc @param',
                                                    jsDoc.loc.start.line + i,
                                                    jsDocLines[i].indexOf('@param')
                                                );
                                            }
                                        }
                                        if (param) {
Branch IfStatement
✓ Positive was executed (if)                                            if (jsDocParamName !== param.name) {···
                                                if (options.checkParamNames) {
                                                    errors.add(
                                                        'Invalid JSDoc @param argument name',
                                                        jsDoc.loc.start.line + i,
                                                        jsDocLines[i].indexOf('@param')
                                                    );
                                                }
                                            }
✓ Negative was executed (else)                                            }···
                                        } else {
                                            if (jsDocParamName !== param.name) {
Branch IfStatement
✓ Positive was executed (if)                                                if (options.checkParamNames) {···
                                                    errors.add(
                                                        'Invalid JSDoc @param argument name',
                                                        jsDoc.loc.start.line + i,
                                                        jsDocLines[i].indexOf('@param')
                                                    );
                                                }
✓ Negative was executed (else)                                                }···
                                            }
                                                if (options.checkParamNames) {
                                                    errors.add(
                                                        'Invalid JSDoc @param argument name',
                                                        jsDoc.loc.start.line + i,
                                                        jsDocLines[i].indexOf('@param')
                                                    );
                                                }
                                            }
                                        } else {
Branch IfStatement
✓ Positive was executed (if)                                            if (options.checkRedundantParams) {···
                                                errors.add(
                                                    'Redundant JSDoc @param',
                                                    jsDoc.loc.start.line + i,
                                                    jsDocLines[i].indexOf('@param')
                                                );
                                            }
✓ Negative was executed (else)                                            }···
                                        }
                                            if (options.checkRedundantParams) {
                                                errors.add(
                                                    'Redundant JSDoc @param',
                                                    jsDoc.loc.start.line + i,
                                                    jsDocLines[i].indexOf('@param')
                                                );
                                            }
                                        }
                                        paramIndex++;
                                    }
                                } else {
                                    errors.add(
                                        'Invalid JSDoc @param',
                                        jsDoc.loc.start.line + i,
                                        jsDocLines[i].indexOf('@param')
                                    );
                                }
                            }
                        }
                    }
                }
            }
        });
Function getJsDocForLine
✓ Was called        function getJsDocForLine(line) {···
            line--;
            for (var i = 0, l = comments.length; i < l; i++) {
                var comment = comments[i];
                if (comment.loc.end.line === line && comment.type === 'Block' && comment.value.charAt(0) === '*') {
                    return comment;
                }
            }
            return null;
        }
        function getJsDocForLine(line) {
            line--;
            for (var i = 0, l = comments.length; i < l; i++) {
                var comment = comments[i];
Branch IfStatement
✓ Positive was executed (if)                if (comment.loc.end.line === line && comment.type === 'Block' && comment.value.charAt(0) === '*') {···
                    return comment;
                }
✓ Negative was executed (else)                }···
            }
Branch LogicalExpression
✓ Was returned                if (comment.loc.end.line === line && comment.type === 'Block' && comment.value.charAt(0) === '*') {
✓ Was returned                if (comment.loc.end.line === line && comment.type === 'Block' && comment.value.charAt(0) === '*') {
Branch LogicalExpression
✓ Was returned                if (comment.loc.end.line === line && comment.type === 'Block' && comment.value.charAt(0) === '*') {
✓ Was returned                if (comment.loc.end.line === line && comment.type === 'Block' && comment.value.charAt(0) === '*') {
                if (comment.loc.end.line === line && comment.type === 'Block' && comment.value.charAt(0) === '*') {
                    return comment;
                }
            }
            return null;
        }
    }
};

require-operator-before-line-break.js
/**
 * Requires operators to appear before line breaks and not after.
 *
 * Types: `Array` or `Boolean`
 *
 * Values: Array of quoted operators or `true` to require all possible binary operators to appear before line breaks
 *
 * JSHint: [`laxbreak`](http://www.jshint.com/docs/options/#laxbreak)
 *
 * #### Example
 *
 * ```js
 * "requireOperatorBeforeLineBreak": [
 *     "?",
 *     "=",
 *     "+",
 *     "-",
 *     "/",
 *     "*",
 *     "==",
 *     "===",
 *     "!=",
 *     "!==",
 *     ">",
 *     ">=",
 *     "<",
 *     "<="
 * ]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * x = y ? 1 : 2;
 * x = y ?
 *     1 : 2;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * x = y
 *     ? 1 : 2;
 * ```
 */
var assert = require('assert');
var defaultOperators = require('../utils').binaryOperators.slice();
defaultOperators.push('?');
Function (anonymous_355)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_356)
✓ Was called    configure: function(operators) {···
        var isTrue = operators === true;

        assert(
            Array.isArray(operators) || isTrue,
            this.getOptionName() + ' option requires array value or true value'
        );

        if (isTrue) {
            operators = defaultOperators;
        }

        this._operatorIndex = {};
        for (var i = 0, l = operators.length; i < l; i++) {
            this._operatorIndex[operators[i]] = true;
        }
    },
    configure: function(operators) {
        var isTrue = operators === true;
        assert(
Branch LogicalExpression
✓ Was returned            Array.isArray(operators) || isTrue,
✓ Was returned            Array.isArray(operators) || isTrue,
            Array.isArray(operators) || isTrue,
            this.getOptionName() + ' option requires array value or true value'
        );
Branch IfStatement
✓ Positive was executed (if)        if (isTrue) {···
            operators = defaultOperators;
        }
✓ Negative was executed (else)        }···

        this._operatorIndex = {};
        if (isTrue) {
            operators = defaultOperators;
        }
        this._operatorIndex = {};
        for (var i = 0, l = operators.length; i < l; i++) {
            this._operatorIndex[operators[i]] = true;
        }
    },
Function (anonymous_357)
✓ Was called    getOptionName: function() {···
        return 'requireOperatorBeforeLineBreak';
    },
    getOptionName: function() {
        return 'requireOperatorBeforeLineBreak';
    },
Function (anonymous_358)
✓ Was called    check: function(file, errors) {···
        var operators = this._operatorIndex;
        var throughTokens = ['?', ','];

        function errorIfApplicable(operatorToken) {
            errors.assert.sameLine({
                token: file.getPrevToken(operatorToken),
                nextToken: operatorToken,
                message: 'Operator ' + operatorToken.value + ' should not be on a new line',
                stickToPreviousToken: true
            });
        }

        throughTokens = throughTokens.filter(function(operator) {
            return operators[operator];
        });

        if (throughTokens.length) {
            file.iterateTokensByType('Punctuator', function(token) {
                var operator = token.value;

                if (throughTokens.every(function() {
                    return throughTokens.indexOf(operator) >= 0;
                })) {
                    errorIfApplicable(token);
                }
            });
        }

        file.iterateNodesByType(
            ['BinaryExpression', 'AssignmentExpression', 'LogicalExpression'],
            function(node) {
                var operator = node.operator;

                if (!operators[operator]) {
                    return;
                }

                var nextToken = file.getFirstNodeToken(node.argument || node.right);
                var token = file.findPrevOperatorToken(nextToken, operator);

                errorIfApplicable(token);
            }
        );
    }
    check: function(file, errors) {
        var operators = this._operatorIndex;
        var throughTokens = ['?', ','];
Function errorIfApplicable
✓ Was called        function errorIfApplicable(operatorToken) {···
            errors.assert.sameLine({
                token: file.getPrevToken(operatorToken),
                nextToken: operatorToken,
                message: 'Operator ' + operatorToken.value + ' should not be on a new line',
                stickToPreviousToken: true
            });
        }
        function errorIfApplicable(operatorToken) {
            errors.assert.sameLine({
                token: file.getPrevToken(operatorToken),
                nextToken: operatorToken,
                message: 'Operator ' + operatorToken.value + ' should not be on a new line',
                stickToPreviousToken: true
            });
        }
Function (anonymous_360)
✓ Was called        throughTokens = throughTokens.filter(function(operator) {···
            return operators[operator];
        });
        throughTokens = throughTokens.filter(function(operator) {
            return operators[operator];
        });
Branch IfStatement
✓ Positive was executed (if)        if (throughTokens.length) {···
            file.iterateTokensByType('Punctuator', function(token) {
                var operator = token.value;

                if (throughTokens.every(function() {
                    return throughTokens.indexOf(operator) >= 0;
                })) {
                    errorIfApplicable(token);
                }
            });
        }
✓ Negative was executed (else)        }···

        file.iterateNodesByType(
        if (throughTokens.length) {
Function (anonymous_361)
✓ Was called            file.iterateTokensByType('Punctuator', function(token) {···
                var operator = token.value;

                if (throughTokens.every(function() {
                    return throughTokens.indexOf(operator) >= 0;
                })) {
                    errorIfApplicable(token);
                }
            });
            file.iterateTokensByType('Punctuator', function(token) {
                var operator = token.value;
Function (anonymous_362)
✓ Was called                if (throughTokens.every(function() {···
                    return throughTokens.indexOf(operator) >= 0;
                })) {
Branch IfStatement
✓ Positive was executed (if)                })) {···
                    errorIfApplicable(token);
                }
✓ Negative was executed (else)                }···
            });
                if (throughTokens.every(function() {
                    return throughTokens.indexOf(operator) >= 0;
                })) {
                    errorIfApplicable(token);
                }
            });
        }
        file.iterateNodesByType(
            ['BinaryExpression', 'AssignmentExpression', 'LogicalExpression'],
Function (anonymous_363)
✓ Was called            function(node) {···
                var operator = node.operator;

                if (!operators[operator]) {
                    return;
                }

                var nextToken = file.getFirstNodeToken(node.argument || node.right);
                var token = file.findPrevOperatorToken(nextToken, operator);

                errorIfApplicable(token);
            }
            function(node) {
                var operator = node.operator;
Branch IfStatement
✓ Positive was executed (if)                if (!operators[operator]) {···
                    return;
                }
✓ Negative was executed (else)                }···

                var nextToken = file.getFirstNodeToken(node.argument || node.right);
                if (!operators[operator]) {
                    return;
                }
Branch LogicalExpression
✓ Was returned                var nextToken = file.getFirstNodeToken(node.argument || node.right);
✗ Was not returned                var nextToken = file.getFirstNodeToken(node.argument || node.right);
                var nextToken = file.getFirstNodeToken(node.argument || node.right);
                var token = file.findPrevOperatorToken(nextToken, operator);
                errorIfApplicable(token);
            }
        );
    }
};

disallow-operator-before-line-break.js
/**
 * Requires putting certain operators on the next line rather than on the current line before a line break.
 *
 * Types: `Array` or `Boolean`
 *
 * Values: Array of operators to apply to or `true`
 *
 * #### Example
 *
 * ```js
 * "disallowOperatorBeforeLineBreak": ["+", "."]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * $el.on( 'click', fn )
 * 	.appendTo( 'body' );
 *
 * var x = 4 + 5
 * 	+ 12 + 13;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * $el.on( 'click', fn ).
 * 	appendTo( 'body' );
 *
 * var x = 4 + 5 +
 * 	12 + 13;
 * ```
 */
var assert = require('assert');
var defaultOperators = require('../utils').binaryOperators.slice().concat(['.']);
Function (anonymous_364)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_365)
✓ Was called    configure: function(operators) {···
        assert(Array.isArray(operators) || operators === true,
            this.getOptionName() + ' option requires array or true value');

        if (operators === true) {
            operators = defaultOperators;
        }
        this._operators = operators;
    },
    configure: function(operators) {
Branch LogicalExpression
✓ Was returned        assert(Array.isArray(operators) || operators === true,
✓ Was returned        assert(Array.isArray(operators) || operators === true,
        assert(Array.isArray(operators) || operators === true,
            this.getOptionName() + ' option requires array or true value');
Branch IfStatement
✓ Positive was executed (if)        if (operators === true) {···
            operators = defaultOperators;
        }
✓ Negative was executed (else)        }···
        this._operators = operators;
        if (operators === true) {
            operators = defaultOperators;
        }
        this._operators = operators;
    },
Function (anonymous_366)
✓ Was called    getOptionName: function() {···
        return 'disallowOperatorBeforeLineBreak';
    },
    getOptionName: function() {
        return 'disallowOperatorBeforeLineBreak';
    },
Function (anonymous_367)
✓ Was called    check: function(file, errors) {···
        file.iterateTokensByTypeAndValue('Punctuator', this._operators, function(token) {
            errors.assert.sameLine({
                token: token,
                nextToken: file.getNextToken(token),
                message: 'Operator needs to either be on the same line or after a line break.'
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_368)
✓ Was called        file.iterateTokensByTypeAndValue('Punctuator', this._operators, function(token) {···
            errors.assert.sameLine({
                token: token,
                nextToken: file.getNextToken(token),
                message: 'Operator needs to either be on the same line or after a line break.'
            });
        });
        file.iterateTokensByTypeAndValue('Punctuator', this._operators, function(token) {
            errors.assert.sameLine({
                token: token,
                nextToken: file.getNextToken(token),
                message: 'Operator needs to either be on the same line or after a line break.'
            });
        });
    }
};

disallow-implicit-type-conversion.js
/**
 * Disallows implicit type conversion.
 *
 * Type: `Array`
 *
 * Values: Array of quoted types
 *
 * #### Example
 *
 * ```js
 * "disallowImplicitTypeConversion": ["numeric", "boolean", "binary", "string"]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * x = Boolean(y);
 * x = Number(y);
 * x = String(y);
 * x = s.indexOf('.') !== -1;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * x = !!y;
 * x = +y;
 * x = '' + y;
 * x = ~s.indexOf('.');
 * ```
 */
var assert = require('assert');
Function (anonymous_369)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_370)
✓ Was called    configure: function(types) {···
        assert(Array.isArray(types), this.getOptionName() + ' option requires array value');
        this._typeIndex = {};
        for (var i = 0, l = types.length; i < l; i++) {
            this._typeIndex[types[i]] = true;
        }
    },
    configure: function(types) {
        assert(Array.isArray(types), this.getOptionName() + ' option requires array value');
        this._typeIndex = {};
        for (var i = 0, l = types.length; i < l; i++) {
            this._typeIndex[types[i]] = true;
        }
    },
Function (anonymous_371)
✓ Was called    getOptionName: function() {···
        return 'disallowImplicitTypeConversion';
    },
    getOptionName: function() {
        return 'disallowImplicitTypeConversion';
    },
Function (anonymous_372)
✓ Was called    check: function(file, errors) {···
        var types = this._typeIndex;
        if (types.numeric || types.boolean || types.binary) {
            file.iterateNodesByType('UnaryExpression', function(node) {
                if (types.numeric && node.operator === '+') {
                    errors.add('Implicit numeric conversion', node.loc.start);
                }
                if (types.binary && node.operator === '~') {
                    errors.add('Implicit binary conversion', node.loc.start);
                }
                if (types.boolean &&
                    node.operator === '!' &&
                    node.argument.type === 'UnaryExpression' &&
                    node.argument.operator === '!'
                ) {
                    errors.add('Implicit boolean conversion', node.loc.start);
                }
            });
        }
        if (types.string) {
            file.iterateNodesByType('BinaryExpression', function(node) {
                if (node.operator === '+' && (
                        (node.left.type === 'Literal' && node.left.value === '') ||
                        (node.right.type === 'Literal' && node.right.value === '')
                    )
                ) {
                    errors.add('Implicit string conversion', node.loc.start);
                }
            });
        }
    }
    check: function(file, errors) {
        var types = this._typeIndex;
Branch IfStatement
✓ Positive was executed (if)        if (types.numeric || types.boolean || types.binary) {···
            file.iterateNodesByType('UnaryExpression', function(node) {
                if (types.numeric && node.operator === '+') {
                    errors.add('Implicit numeric conversion', node.loc.start);
                }
                if (types.binary && node.operator === '~') {
                    errors.add('Implicit binary conversion', node.loc.start);
                }
                if (types.boolean &&
                    node.operator === '!' &&
                    node.argument.type === 'UnaryExpression' &&
                    node.argument.operator === '!'
                ) {
                    errors.add('Implicit boolean conversion', node.loc.start);
                }
            });
        }
✓ Negative was executed (else)        }···
        if (types.string) {
Branch LogicalExpression
✓ Was returned        if (types.numeric || types.boolean || types.binary) {
✓ Was returned        if (types.numeric || types.boolean || types.binary) {
Branch LogicalExpression
✓ Was returned        if (types.numeric || types.boolean || types.binary) {
✓ Was returned        if (types.numeric || types.boolean || types.binary) {
        if (types.numeric || types.boolean || types.binary) {
Function (anonymous_373)
✓ Was called            file.iterateNodesByType('UnaryExpression', function(node) {···
                if (types.numeric && node.operator === '+') {
                    errors.add('Implicit numeric conversion', node.loc.start);
                }
                if (types.binary && node.operator === '~') {
                    errors.add('Implicit binary conversion', node.loc.start);
                }
                if (types.boolean &&
                    node.operator === '!' &&
                    node.argument.type === 'UnaryExpression' &&
                    node.argument.operator === '!'
                ) {
                    errors.add('Implicit boolean conversion', node.loc.start);
                }
            });
            file.iterateNodesByType('UnaryExpression', function(node) {
Branch IfStatement
✓ Positive was executed (if)                if (types.numeric && node.operator === '+') {···
                    errors.add('Implicit numeric conversion', node.loc.start);
                }
✓ Negative was executed (else)                }···
                if (types.binary && node.operator === '~') {
Branch LogicalExpression
✓ Was returned                if (types.numeric && node.operator === '+') {
✓ Was returned                if (types.numeric && node.operator === '+') {
                if (types.numeric && node.operator === '+') {
                    errors.add('Implicit numeric conversion', node.loc.start);
                }
Branch IfStatement
✓ Positive was executed (if)                if (types.binary && node.operator === '~') {···
                    errors.add('Implicit binary conversion', node.loc.start);
                }
✓ Negative was executed (else)                }···
                if (types.boolean &&
Branch LogicalExpression
✓ Was returned                if (types.binary && node.operator === '~') {
✓ Was returned                if (types.binary && node.operator === '~') {
                if (types.binary && node.operator === '~') {
                    errors.add('Implicit binary conversion', node.loc.start);
                }
Branch IfStatement
✓ Positive was executed (if)                ) {···
                    errors.add('Implicit boolean conversion', node.loc.start);
                }
✓ Negative was executed (else)                }···
            });
Branch LogicalExpression
✓ Was returned                    node.argument.operator === '!'
✓ Was returned                if (types.boolean &&···
                    node.operator === '!' &&
                    node.argument.type === 'UnaryExpression' &&
Branch LogicalExpression
✓ Was returned                    node.argument.type === 'UnaryExpression' &&
✓ Was returned                if (types.boolean &&···
                    node.operator === '!' &&
Branch LogicalExpression
✓ Was returned                    node.operator === '!' &&
✓ Was returned                if (types.boolean &&
                if (types.boolean &&
                    node.operator === '!' &&
                    node.argument.type === 'UnaryExpression' &&
                    node.argument.operator === '!'
                ) {
                    errors.add('Implicit boolean conversion', node.loc.start);
                }
            });
        }
Branch IfStatement
✓ Positive was executed (if)        if (types.string) {···
            file.iterateNodesByType('BinaryExpression', function(node) {
                if (node.operator === '+' && (
                        (node.left.type === 'Literal' && node.left.value === '') ||
                        (node.right.type === 'Literal' && node.right.value === '')
                    )
                ) {
                    errors.add('Implicit string conversion', node.loc.start);
                }
            });
        }
✓ Negative was executed (else)        }···
    }
        if (types.string) {
Function (anonymous_374)
✓ Was called            file.iterateNodesByType('BinaryExpression', function(node) {···
                if (node.operator === '+' && (
                        (node.left.type === 'Literal' && node.left.value === '') ||
                        (node.right.type === 'Literal' && node.right.value === '')
                    )
                ) {
                    errors.add('Implicit string conversion', node.loc.start);
                }
            });
            file.iterateNodesByType('BinaryExpression', function(node) {
Branch IfStatement
✓ Positive was executed (if)                ) {···
                    errors.add('Implicit string conversion', node.loc.start);
                }
✓ Negative was executed (else)                }···
            });
Branch LogicalExpression
✓ Was returned                        (node.left.type === 'Literal' && node.left.value === '') ||···
                        (node.right.type === 'Literal' && node.right.value === '')
✓ Was returned                if (node.operator === '+' && (
                if (node.operator === '+' && (
Branch LogicalExpression
✓ Was returned                        (node.right.type === 'Literal' && node.right.value === '')
✓ Was returned                        (node.left.type === 'Literal' && node.left.value === '') ||
Branch LogicalExpression
✓ Was returned                        (node.left.type === 'Literal' && node.left.value === '') ||
✓ Was returned                        (node.left.type === 'Literal' && node.left.value === '') ||
                        (node.left.type === 'Literal' && node.left.value === '') ||
Branch LogicalExpression
✓ Was returned                        (node.right.type === 'Literal' && node.right.value === '')
✓ Was returned                        (node.right.type === 'Literal' && node.right.value === '')
                        (node.right.type === 'Literal' && node.right.value === '')
                    )
                ) {
                    errors.add('Implicit string conversion', node.loc.start);
                }
            });
        }
    }
};

require-camelcase-or-uppercase-identifiers.js
/**
 * Requires identifiers to be camelCased or UPPERCASE_WITH_UNDERSCORES
 *
 * Types: `Boolean` or `String`
 *
 * Values:
 *
 * - `true`
 * - `"ignoreProperties"` allows an exception for object property names.
 *
 * JSHint: [`camelcase`](http://jshint.com/docs/options/#camelcase)
 *
 * #### Example
 *
 * ```js
 * "requireCamelCaseOrUpperCaseIdentifiers": true
 * ```
 *
 * ##### Valid for mode `true`
 *
 * ```js
 * var camelCase = 0;
 * var CamelCase = 1;
 * var _camelCase = 2;
 * var camelCase_ = 3;
 * var UPPER_CASE = 4;
 * ```
 *
 * ##### Invalid for mode `true`
 *
 * ```js
 * var lower_case = 1;
 * var Mixed_case = 2;
 * var mixed_Case = 3;
 * ```
 *
 * ##### Valid for mode `ignoreProperties`
 *
 * ```js
 * var camelCase = 0;
 * var CamelCase = 1;
 * var _camelCase = 2;
 * var camelCase_ = 3;
 * var UPPER_CASE = 4;
 * var obj.snake_case = 5;
 * var camelCase = { snake_case: 6 };
 * ```
 *
 * ##### Invalid for mode `ignoreProperties`
 *
 * ```js
 * var lower_case = 1;
 * var Mixed_case = 2;
 * var mixed_Case = 3;
 * var snake_case = { snake_case: 6 };
 * ```
 */
var assert = require('assert');
Function (anonymous_375)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_376)
✓ Was called    configure: function(options) {···
        assert(
            options === true || options === 'ignoreProperties',
            this.getOptionName() + ' option requires a true value or `ignoreProperties`'
        );

        this._ignoreProperties = (options === 'ignoreProperties');
    },
    configure: function(options) {
        assert(
Branch LogicalExpression
✓ Was returned            options === true || options === 'ignoreProperties',
✓ Was returned            options === true || options === 'ignoreProperties',
            options === true || options === 'ignoreProperties',
            this.getOptionName() + ' option requires a true value or `ignoreProperties`'
        );
        this._ignoreProperties = (options === 'ignoreProperties');
    },
Function (anonymous_377)
✓ Was called    getOptionName: function() {···
        return 'requireCamelCaseOrUpperCaseIdentifiers';
    },
    getOptionName: function() {
        return 'requireCamelCaseOrUpperCaseIdentifiers';
    },
Function (anonymous_378)
✓ Was called    check: function(file, errors) {···
        file.iterateTokensByType('Identifier', function(token) {
            var value = token.value;
            if (value.replace(/^_+|_+$/g, '').indexOf('_') === -1 || value.toUpperCase() === value) {
                return;
            }
            if (this._ignoreProperties) {
                var nextToken = file.getNextToken(token);
                var prevToken = file.getPrevToken(token);

                if (nextToken && nextToken.value === ':') {
                    return;
                }

                if (prevToken && (prevToken.value === '.' ||
                    prevToken.value === 'get' || prevToken.value === 'set')) {
                    return;
                }
            }
            errors.add(
                'All identifiers must be camelCase or UPPER_CASE',
                token.loc.start.line,
                token.loc.start.column
            );
        }.bind(this));
    }
    check: function(file, errors) {
Function (anonymous_379)
✓ Was called        file.iterateTokensByType('Identifier', function(token) {···
            var value = token.value;
            if (value.replace(/^_+|_+$/g, '').indexOf('_') === -1 || value.toUpperCase() === value) {
                return;
            }
            if (this._ignoreProperties) {
                var nextToken = file.getNextToken(token);
                var prevToken = file.getPrevToken(token);

                if (nextToken && nextToken.value === ':') {
                    return;
                }

                if (prevToken && (prevToken.value === '.' ||
                    prevToken.value === 'get' || prevToken.value === 'set')) {
                    return;
                }
            }
            errors.add(
                'All identifiers must be camelCase or UPPER_CASE',
                token.loc.start.line,
                token.loc.start.column
            );
        }.bind(this));
        file.iterateTokensByType('Identifier', function(token) {
            var value = token.value;
Branch IfStatement
✓ Positive was executed (if)            if (value.replace(/^_+|_+$/g, '').indexOf('_') === -1 || value.toUpperCase() === value) {···
                return;
            }
✓ Negative was executed (else)            }···
            if (this._ignoreProperties) {
Branch LogicalExpression
✓ Was returned            if (value.replace(/^_+|_+$/g, '').indexOf('_') === -1 || value.toUpperCase() === value) {
✓ Was returned            if (value.replace(/^_+|_+$/g, '').indexOf('_') === -1 || value.toUpperCase() === value) {
            if (value.replace(/^_+|_+$/g, '').indexOf('_') === -1 || value.toUpperCase() === value) {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (this._ignoreProperties) {···
                var nextToken = file.getNextToken(token);
                var prevToken = file.getPrevToken(token);

                if (nextToken && nextToken.value === ':') {
                    return;
                }

                if (prevToken && (prevToken.value === '.' ||
                    prevToken.value === 'get' || prevToken.value === 'set')) {
                    return;
                }
            }
✓ Negative was executed (else)            }···
            errors.add(
            if (this._ignoreProperties) {
                var nextToken = file.getNextToken(token);
                var prevToken = file.getPrevToken(token);
Branch IfStatement
✓ Positive was executed (if)                if (nextToken && nextToken.value === ':') {···
                    return;
                }
✓ Negative was executed (else)                }···

                if (prevToken && (prevToken.value === '.' ||
Branch LogicalExpression
✓ Was returned                if (nextToken && nextToken.value === ':') {
✗ Was not returned                if (nextToken && nextToken.value === ':') {
                if (nextToken && nextToken.value === ':') {
                    return;
                }
Branch IfStatement
✓ Positive was executed (if)                    prevToken.value === 'get' || prevToken.value === 'set')) {···
                    return;
                }
✓ Negative was executed (else)                }···
            }
Branch LogicalExpression
✓ Was returned                if (prevToken && (prevToken.value === '.' ||···
                    prevToken.value === 'get' || prevToken.value === 'set')) {
✓ Was returned                if (prevToken && (prevToken.value === '.' ||
Branch LogicalExpression
✓ Was returned                    prevToken.value === 'get' || prevToken.value === 'set')) {
✓ Was returned                if (prevToken && (prevToken.value === '.' ||···
                    prevToken.value === 'get' || prevToken.value === 'set')) {
Branch LogicalExpression
✓ Was returned                    prevToken.value === 'get' || prevToken.value === 'set')) {
✓ Was returned                if (prevToken && (prevToken.value === '.' ||
                if (prevToken && (prevToken.value === '.' ||
                    prevToken.value === 'get' || prevToken.value === 'set')) {
                    return;
                }
            }
            errors.add(
                'All identifiers must be camelCase or UPPER_CASE',
                token.loc.start.line,
                token.loc.start.column
            );
        }.bind(this));
    }
};

disallow-keywords.js
/**
 * Disallows usage of specified keywords.
 *
 * Type: `Array`
 *
 * Values: Array of quoted keywords
 *
 * #### Example
 *
 * ```js
 * "disallowKeywords": ["with"]
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * with (x) {
 *     prop++;
 * }
 * ```
 */
var assert = require('assert');
Function (anonymous_380)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_381)
✓ Was called    configure: function(keywords) {···
        assert(Array.isArray(keywords), this.getOptionName() + ' option requires array value');
        this._keywords = keywords;
    },
    configure: function(keywords) {
        assert(Array.isArray(keywords), this.getOptionName() + ' option requires array value');
        this._keywords = keywords;
    },
Function (anonymous_382)
✓ Was called    getOptionName: function() {···
        return 'disallowKeywords';
    },
    getOptionName: function() {
        return 'disallowKeywords';
    },
Function (anonymous_383)
✓ Was called    check: function(file, errors) {···
        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {
            errors.add(
                'Illegal keyword: ' + token.value,
                token.loc.start
            );
        });
    }
    check: function(file, errors) {
Function (anonymous_384)
✓ Was called        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {···
            errors.add(
                'Illegal keyword: ' + token.value,
                token.loc.start
            );
        });
        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {
            errors.add(
                'Illegal keyword: ' + token.value,
                token.loc.start
            );
        });
    }
};

disallow-multiple-line-breaks.js
/**
 * Disallows multiple blank lines in a row.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowMultipleLineBreaks": true
 * ```
 *
 * ##### Valid
 * ```js
 * var x = 1;
 *
 * x++;
 * ```
 *
 * ##### Invalid
 * ```js
 * var x = 1;
 *
 *
 * x++;
 * ```
 */
var assert = require('assert');
Function (anonymous_385)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_386)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_387)
✓ Was called    getOptionName: function() {···
        return 'disallowMultipleLineBreaks';
    },
    getOptionName: function() {
        return 'disallowMultipleLineBreaks';
    },
Function (anonymous_388)
✓ Was called    check: function(file, errors) {···
        // Iterate over all tokens (including comments)
        file.getTokens().forEach(function(token, index, tokens) {
            // If there are no trailing tokens, exit early
            var nextToken = tokens[index + 1];
            if (!nextToken) {
                return;
            }

            errors.assert.linesBetween({
                token: token,
                nextToken: nextToken,
                atMost: 2,
            });
        });
    }
    check: function(file, errors) {
        // Iterate over all tokens (including comments)
Function (anonymous_389)
✓ Was called        file.getTokens().forEach(function(token, index, tokens) {···
            // If there are no trailing tokens, exit early
            var nextToken = tokens[index + 1];
            if (!nextToken) {
                return;
            }

            errors.assert.linesBetween({
                token: token,
                nextToken: nextToken,
                atMost: 2,
            });
        });
        file.getTokens().forEach(function(token, index, tokens) {
            // If there are no trailing tokens, exit early
            var nextToken = tokens[index + 1];
Branch IfStatement
✓ Positive was executed (if)            if (!nextToken) {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.assert.linesBetween({
            if (!nextToken) {
                return;
            }
            errors.assert.linesBetween({
                token: token,
                nextToken: nextToken,
                atMost: 2,
            });
        });
    }
};

disallow-multiple-line-strings.js
/**
 * Disallows strings that span multiple lines without using concatenation.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * JSHint: [`multistr`](http://www.jshint.com/docs/options/#multistr)
 *
 * #### Example
 *
 * ```js
 * "disallowMultipleLineStrings": true
 * ```
 *
 * ##### Valid
 * ```js
 * var x = "multi" +
 *         "line";
 * var y = "single line";
 * ```
 *
 * ##### Invalid
 * ```js
 * var x = "multi \
 *         line";
 * ```
 */
var assert = require('assert');
Function (anonymous_390)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_391)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_392)
✓ Was called    getOptionName: function() {···
        return 'disallowMultipleLineStrings';
    },
    getOptionName: function() {
        return 'disallowMultipleLineStrings';
    },
Function (anonymous_393)
✓ Was called    check: function(file, errors) {···
        file.iterateTokensByType('String', function(token) {
            if (token.loc.start.line !== token.loc.end.line) {
                errors.add(
                    'Multiline strings are disallowed.',
                    token.loc.start.line,
                    token.loc.start.column
                );
            }
        });
    }
    check: function(file, errors) {
Function (anonymous_394)
✓ Was called        file.iterateTokensByType('String', function(token) {···
            if (token.loc.start.line !== token.loc.end.line) {
                errors.add(
                    'Multiline strings are disallowed.',
                    token.loc.start.line,
                    token.loc.start.column
                );
            }
        });
        file.iterateTokensByType('String', function(token) {
Branch IfStatement
✓ Positive was executed (if)            if (token.loc.start.line !== token.loc.end.line) {···
                errors.add(
                    'Multiline strings are disallowed.',
                    token.loc.start.line,
                    token.loc.start.column
                );
            }
✓ Negative was executed (else)            }···
        });
            if (token.loc.start.line !== token.loc.end.line) {
                errors.add(
                    'Multiline strings are disallowed.',
                    token.loc.start.line,
                    token.loc.start.column
                );
            }
        });
    }
};

disallow-multiple-spaces.js
/**
 * Disallows multiple indentation characters (tabs or spaces) between identifiers, keywords, and any other token
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowMultipleSpaces": true
 * ```
 *
 * ##### Valid
 * ```js
 * var x = "hello";
 * function y() {}
 * ```
 *
 * ##### Invalid
 * ```js
 * var x  = "hello";
 * function  y() {}
 * ```
 */
var assert = require('assert');
Function (anonymous_395)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_396)
✓ Was called    configure: function(options) {···
        assert(
            options === true ||
            typeof options === 'object' &&
            options.allowEOLComments === true,
            this.getOptionName() + ' option requires true value ' +
            'or an object with `allowEOLComments` property'
        );

        this.allowEOLComments = options.allowEOLComments;
    },
    configure: function(options) {
        assert(
Branch LogicalExpression
✓ Was returned            typeof options === 'object' &&···
            options.allowEOLComments === true,
✓ Was returned            options === true ||
            options === true ||
Branch LogicalExpression
✓ Was returned            options.allowEOLComments === true,
✓ Was returned            typeof options === 'object' &&
            typeof options === 'object' &&
            options.allowEOLComments === true,
            this.getOptionName() + ' option requires true value ' +
            'or an object with `allowEOLComments` property'
        );
        this.allowEOLComments = options.allowEOLComments;
    },
Function (anonymous_397)
✓ Was called    getOptionName: function() {···
        return 'disallowMultipleSpaces';
    },
    getOptionName: function() {
        return 'disallowMultipleSpaces';
    },
Function (anonymous_398)
✓ Was called    check: function(file, errors) {···
        // Iterate over all tokens (including comments)
        var _this = this;
        file.getTokens().forEach(function(token, index, tokens) {
            // If there are no trailing tokens, exit early
            var nextToken = tokens[index + 1];
            if (!nextToken) {
                return;
            }

            // If we are allowing EOL comments and the next token is an EOL comment skip it
            // We don't need to check the current token since EOL comments must be on separate lines from the next one
            if (_this.allowEOLComments && nextToken.type === 'Line') {
                return;
            }

            // Verify we have at most 1 space between this token and the next (won't fail for different lines)
            errors.assert.spacesBetween({
                token: token,
                nextToken: nextToken,
                atMost: 1,
            });
        });
    }
    check: function(file, errors) {
        // Iterate over all tokens (including comments)
        var _this = this;
Function (anonymous_399)
✓ Was called        file.getTokens().forEach(function(token, index, tokens) {···
            // If there are no trailing tokens, exit early
            var nextToken = tokens[index + 1];
            if (!nextToken) {
                return;
            }

            // If we are allowing EOL comments and the next token is an EOL comment skip it
            // We don't need to check the current token since EOL comments must be on separate lines from the next one
            if (_this.allowEOLComments && nextToken.type === 'Line') {
                return;
            }

            // Verify we have at most 1 space between this token and the next (won't fail for different lines)
            errors.assert.spacesBetween({
                token: token,
                nextToken: nextToken,
                atMost: 1,
            });
        });
        file.getTokens().forEach(function(token, index, tokens) {
            // If there are no trailing tokens, exit early
            var nextToken = tokens[index + 1];
Branch IfStatement
✓ Positive was executed (if)            if (!nextToken) {···
                return;
            }
✓ Negative was executed (else)            }···

            // If we are allowing EOL comments and the next token is an EOL comment skip it
            if (!nextToken) {
                return;
            }
            // If we are allowing EOL comments and the next token is an EOL comment skip it
            // We don't need to check the current token since EOL comments must be on separate lines from the next one
Branch IfStatement
✓ Positive was executed (if)            if (_this.allowEOLComments && nextToken.type === 'Line') {···
                return;
            }
✓ Negative was executed (else)            }···

            // Verify we have at most 1 space between this token and the next (won't fail for different lines)
Branch LogicalExpression
✓ Was returned            if (_this.allowEOLComments && nextToken.type === 'Line') {
✓ Was returned            if (_this.allowEOLComments && nextToken.type === 'Line') {
            if (_this.allowEOLComments && nextToken.type === 'Line') {
                return;
            }
            // Verify we have at most 1 space between this token and the next (won't fail for different lines)
            errors.assert.spacesBetween({
                token: token,
                nextToken: nextToken,
                atMost: 1,
            });
        });
    }
};

validate-line-breaks.js
/**
 * Option to check line break characters
 *
 * Type: `String`
 *
 * Values: `"CR"`, `"LF"`, `"CRLF"`
 *
 * #### Example
 *
 * ```js
 * "validateLineBreaks": "LF"
 * ```
 *
 * ##### Valid
 * ```js
 * var x = 1;<LF>
 * x++;
 * ```
 *
 * ##### Invalid
 * ```js
 * var x = 1;<CRLF>
 * x++;
 * ```
 */
var assert = require('assert');
Function (anonymous_400)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_401)
✓ Was called    configure: function(options) {···
        assert(
            typeof options === 'string' || typeof options === 'object',
            this.getOptionName() + ' option requires string or object value'
        );

        if (typeof options === 'string') {
            options = { character: options };
        }

        var lineBreaks = {
            CR: '\r',
            LF: '\n',
            CRLF: '\r\n'
        };
        this._allowedLineBreak = lineBreaks[options.character];

        this._reportOncePerFile = options.reportOncePerFile !== false;
    },
    configure: function(options) {
        assert(
Branch LogicalExpression
✓ Was returned            typeof options === 'string' || typeof options === 'object',
✓ Was returned            typeof options === 'string' || typeof options === 'object',
            typeof options === 'string' || typeof options === 'object',
            this.getOptionName() + ' option requires string or object value'
        );
Branch IfStatement
✓ Positive was executed (if)        if (typeof options === 'string') {···
            options = { character: options };
        }
✓ Negative was executed (else)        }···

        var lineBreaks = {
        if (typeof options === 'string') {
            options = { character: options };
        }
        var lineBreaks = {
            CR: '\r',
            LF: '\n',
            CRLF: '\r\n'
        };
        this._allowedLineBreak = lineBreaks[options.character];
        this._reportOncePerFile = options.reportOncePerFile !== false;
    },
Function (anonymous_402)
✓ Was called    getOptionName: function() {···
        return 'validateLineBreaks';
    },
    getOptionName: function() {
        return 'validateLineBreaks';
    },
Function (anonymous_403)
✓ Was called    check: function(file, errors) {···
        var lines = file.getLines();
        if (lines.length < 2) {
            return;
        }

        file.getLineBreaks().some(function(lineBreak, i) {
            if (lineBreak !== this._allowedLineBreak) {
                errors.add('Invalid line break', i + 1, lines[i].length);
                return this._reportOncePerFile;
            }
        }, this);
    }
    check: function(file, errors) {
        var lines = file.getLines();
Branch IfStatement
✓ Positive was executed (if)        if (lines.length < 2) {···
            return;
        }
✓ Negative was executed (else)        }···

        file.getLineBreaks().some(function(lineBreak, i) {
        if (lines.length < 2) {
            return;
        }
Function (anonymous_404)
✓ Was called        file.getLineBreaks().some(function(lineBreak, i) {···
            if (lineBreak !== this._allowedLineBreak) {
                errors.add('Invalid line break', i + 1, lines[i].length);
                return this._reportOncePerFile;
            }
        }, this);
        file.getLineBreaks().some(function(lineBreak, i) {
Branch IfStatement
✓ Positive was executed (if)            if (lineBreak !== this._allowedLineBreak) {···
                errors.add('Invalid line break', i + 1, lines[i].length);
                return this._reportOncePerFile;
            }
✓ Negative was executed (else)            }···
        }, this);
            if (lineBreak !== this._allowedLineBreak) {
                errors.add('Invalid line break', i + 1, lines[i].length);
                return this._reportOncePerFile;
            }
        }, this);
    }
};

validate-quote-marks.js
/**
 * Requires all quote marks to be either the supplied value, or consistent if `true`
 *
 * Types: `Boolean`, `String` or `Object`
 *
 * Values:
 *  - `"\""`: all strings require double quotes
 *  - `"'"`: all strings require single quotes
 *  - `true`: all strings require the quote mark first encountered in the source code
 *  - `Object`:
 *     - `escape`: allow the "other" quote mark to be used, but only to avoid having to escape
 *     - `mark`: the same effect as the non-object values
 *
 * JSHint: [`quotmark`](http://jshint.com/docs/options/#quotmark)
 *
 * #### Example
 *
 * ```js
 * "validateQuoteMarks": "\""
 * ```
 * ```js
 * "validateQuoteMarks": { "mark": "\"", "escape": true }
 * ```
 *
 * ##### Valid example for mode `{ "mark": "\"", "escape": true }`
 *
 * ```js
 * var x = "x";
 * var y = '"x"';
 * ```
 * ##### Invalid example for mode `{ "mark": "\"", "escape": true }`
 *
 * ```js
 * var x = "x";
 * var y = 'x';
 * ```
 *
 * ##### Valid example for mode `"\""` or mode `true`
 *
 * ```js
 * var x = "x";
 * ```
 *
 * ##### Valid example for mode `"'"` or mode `true`
 *
 * ```js
 * var x = 'x';
 * ```
 *
 * ##### Invalid example for mode `true`
 *
 * ```js
 * var x = "x", y = 'y';
 * ```
 */
var assert = require('assert');
Function (anonymous_405)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_406)
✓ Was called    configure: function(quoteMark) {···
        this._allowEscape = false;

        if (typeof quoteMark === 'object') {
            assert(
                typeof quoteMark.escape === 'boolean' && quoteMark.mark !== undefined,
                this.getOptionName() + ' option requires the "escape" and "mark" property to be defined'
            );
            this._allowEscape = quoteMark.escape;
            quoteMark = quoteMark.mark;
        }

        assert(
            quoteMark === '"' || quoteMark === '\'' || quoteMark === true,
            this.getOptionName() + ' option requires \'"\', "\'", or boolean true'
        );

        this._quoteMark = quoteMark;
    },
    configure: function(quoteMark) {
        this._allowEscape = false;
Branch IfStatement
✓ Positive was executed (if)        if (typeof quoteMark === 'object') {···
            assert(
                typeof quoteMark.escape === 'boolean' && quoteMark.mark !== undefined,
                this.getOptionName() + ' option requires the "escape" and "mark" property to be defined'
            );
            this._allowEscape = quoteMark.escape;
            quoteMark = quoteMark.mark;
        }
✓ Negative was executed (else)        }···

        assert(
        if (typeof quoteMark === 'object') {
            assert(
Branch LogicalExpression
✓ Was returned                typeof quoteMark.escape === 'boolean' && quoteMark.mark !== undefined,
✓ Was returned                typeof quoteMark.escape === 'boolean' && quoteMark.mark !== undefined,
                typeof quoteMark.escape === 'boolean' && quoteMark.mark !== undefined,
                this.getOptionName() + ' option requires the "escape" and "mark" property to be defined'
            );
            this._allowEscape = quoteMark.escape;
            quoteMark = quoteMark.mark;
        }
        assert(
Branch LogicalExpression
✓ Was returned            quoteMark === '"' || quoteMark === '\'' || quoteMark === true,
✓ Was returned            quoteMark === '"' || quoteMark === '\'' || quoteMark === true,
Branch LogicalExpression
✓ Was returned            quoteMark === '"' || quoteMark === '\'' || quoteMark === true,
✓ Was returned            quoteMark === '"' || quoteMark === '\'' || quoteMark === true,
            quoteMark === '"' || quoteMark === '\'' || quoteMark === true,
            this.getOptionName() + ' option requires \'"\', "\'", or boolean true'
        );
        this._quoteMark = quoteMark;
    },
Function (anonymous_407)
✓ Was called    getOptionName: function() {···
        return 'validateQuoteMarks';
    },
    getOptionName: function() {
        return 'validateQuoteMarks';
    },
Function (anonymous_408)
✓ Was called    check: function(file, errors) {···
        var quoteMark = this._quoteMark;
        var allowEscape = this._allowEscape;
        var opposite = {
            '"': '\'',
            '\'': '"'
        };

        file.iterateTokensByType('String', function(token) {
            var str = token.value;
            var mark = str[0];
            var stripped = str.substring(1, str.length - 1);

            if (quoteMark === true) {
                quoteMark = mark;
            }

            if (mark !== quoteMark) {
                if (allowEscape && stripped.indexOf(opposite[mark]) > -1) {
                    return;
                }

                errors.add(
                    'Invalid quote mark found',
                    token.loc.start.line,
                    token.loc.start.column
                );
            }
        });
    }
    check: function(file, errors) {
        var quoteMark = this._quoteMark;
        var allowEscape = this._allowEscape;
        var opposite = {
            '"': '\'',
            '\'': '"'
        };
Function (anonymous_409)
✓ Was called        file.iterateTokensByType('String', function(token) {···
            var str = token.value;
            var mark = str[0];
            var stripped = str.substring(1, str.length - 1);

            if (quoteMark === true) {
                quoteMark = mark;
            }

            if (mark !== quoteMark) {
                if (allowEscape && stripped.indexOf(opposite[mark]) > -1) {
                    return;
                }

                errors.add(
                    'Invalid quote mark found',
                    token.loc.start.line,
                    token.loc.start.column
                );
            }
        });
        file.iterateTokensByType('String', function(token) {
            var str = token.value;
            var mark = str[0];
            var stripped = str.substring(1, str.length - 1);
Branch IfStatement
✓ Positive was executed (if)            if (quoteMark === true) {···
                quoteMark = mark;
            }
✓ Negative was executed (else)            }···

            if (mark !== quoteMark) {
            if (quoteMark === true) {
                quoteMark = mark;
            }
Branch IfStatement
✓ Positive was executed (if)            if (mark !== quoteMark) {···
                if (allowEscape && stripped.indexOf(opposite[mark]) > -1) {
                    return;
                }

                errors.add(
                    'Invalid quote mark found',
                    token.loc.start.line,
                    token.loc.start.column
                );
            }
✓ Negative was executed (else)            }···
        });
            if (mark !== quoteMark) {
Branch IfStatement
✓ Positive was executed (if)                if (allowEscape && stripped.indexOf(opposite[mark]) > -1) {···
                    return;
                }
✓ Negative was executed (else)                }···

                errors.add(
Branch LogicalExpression
✓ Was returned                if (allowEscape && stripped.indexOf(opposite[mark]) > -1) {
✓ Was returned                if (allowEscape && stripped.indexOf(opposite[mark]) > -1) {
                if (allowEscape && stripped.indexOf(opposite[mark]) > -1) {
                    return;
                }
                errors.add(
                    'Invalid quote mark found',
                    token.loc.start.line,
                    token.loc.start.column
                );
            }
        });
    }
};

validate-indentation.js
/**
 * Validates indentation for switch statements and block statements
 *
 * Types: `Integer`, `String` or `Object`
 *
 * Values:
 *  - `Integer`: A positive number of spaces
 *  - `String`: `"\t"` for tab indentation
 *  - `Object`:
 *     - `value`: (required) the same effect as the non-object values
 *     - `includeEmptyLines`: (default: `false`) require empty lines to be indented
 *
 * JSHint: [`indent`](http://jshint.com/docs/options/#indent)
 *
 * #### Example
 *
 * ```js
 * "validateIndentation": "\t"
 * ```
 *
 * ##### Valid example for mode `2`
 *
 * ```js
 * if (a) {
 *   b=c;
 *   function(d) {
 *     e=f;
 *   }
 * }
 * ```
 *
 * ##### Invalid example for mode `2`
 *
 * ```js
 * if (a) {
 *    b=c;
 * function(d) {
 *        e=f;
 * }
 * }
 * ```
 *
 * ##### Valid example for mode `"\t"`
 *
 * ```js
 * if (a) {
 *     b=c;
 *     function(d) {
 *         e=f;
 *     }
 * }
 * ```
 *
 * ##### Invalid example for mode `"\t"`
 *
 * ```js
 * if (a) {
 *      b=c;
 * function(d) {
 *            e=f;
 *  }
 * }
 * ```
 *
 * ##### Valid example for mode `{ "value": "\t", "includeEmptyLines": true }`
 * ```js
 * if (a) {
 *     b=c;
 *     function(d) {
 *         e=f;
 *     }
 *
 * } // single tab character on previous line
 * ```
 *
 * ##### Invalid example for mode `{ "value": "\t", "includeEmptyLines": true }`
 * ```js
 * if (a) {
 *     b=c;
 *     function(d) {
 *         e=f;
 *     }
 *
 * } // no tab character on previous line
 * ```
 */
var assert = require('assert');
var utils = require('../utils');
var blockParents = [
    'IfStatement',
    'WhileStatement',
    'DoWhileStatement',
    'ForStatement',
    'ForInStatement',
    'ForOfStatement',
    'FunctionDeclaration',
    'FunctionExpression',
    'ArrowExpression',
    'CatchClause',
];
var indentableNodes = {
    BlockStatement: 'body',
    Program: 'body',
    ObjectExpression: 'properties',
    ArrayExpression: 'elements',
    SwitchStatement: 'cases',
    SwitchCase: 'consequent'
};
Function (anonymous_410)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_411)
✓ Was called    configure: function(options) {···
        this._includeEmptyLines = false;

        if (typeof options === 'object') {
            this._includeEmptyLines = (options.includeEmptyLines === true);
            options = options.value;
        }

        assert(
            options === '\t' ||
                (typeof options === 'number' && options > 0),
            this.getOptionName() + ' option requires a positive number of spaces or "\\t"' +
            ' or options object with "value" property'
        );

        if (typeof options === 'number') {
            this._indentChar = ' ';
            this._indentSize = options;
        } else {
            this._indentChar = '\t';
            this._indentSize = 1;
        }

        this._breakIndents = null;
        this._moduleIndents = null;
    },
    configure: function(options) {
        this._includeEmptyLines = false;
Branch IfStatement
✓ Positive was executed (if)        if (typeof options === 'object') {···
            this._includeEmptyLines = (options.includeEmptyLines === true);
            options = options.value;
        }
✓ Negative was executed (else)        }···

        assert(
        if (typeof options === 'object') {
            this._includeEmptyLines = (options.includeEmptyLines === true);
            options = options.value;
        }
        assert(
Branch LogicalExpression
✓ Was returned                (typeof options === 'number' && options > 0),
✓ Was returned            options === '\t' ||
            options === '\t' ||
Branch LogicalExpression
✓ Was returned                (typeof options === 'number' && options > 0),
✓ Was returned                (typeof options === 'number' && options > 0),
                (typeof options === 'number' && options > 0),
            this.getOptionName() + ' option requires a positive number of spaces or "\\t"' +
            ' or options object with "value" property'
        );
Branch IfStatement
✓ Positive was executed (if)        if (typeof options === 'number') {···
            this._indentChar = ' ';
            this._indentSize = options;
        } else {
✓ Negative was executed (else)        } else {···
            this._indentChar = '\t';
            this._indentSize = 1;
        }
        if (typeof options === 'number') {
            this._indentChar = ' ';
            this._indentSize = options;
        } else {
            this._indentChar = '\t';
            this._indentSize = 1;
        }
        this._breakIndents = null;
        this._moduleIndents = null;
    },
Function (anonymous_412)
✓ Was called    getOptionName: function() {···
        return 'validateIndentation';
    },
    getOptionName: function() {
        return 'validateIndentation';
    },
Function (anonymous_413)
✓ Was called    check: function(file, errors) {···
        function markCheckLine(line) {
            linesToCheck[line].check = true;
        }

        function markCheck(node) {
            markCheckLine(node.loc.start.line - 1);
        }

        function markEndCheck(node) {
            markCheckLine(node.loc.end.line - 1);
        }

        function markPush(node, indents) {
            linesToCheck[node.loc.start.line - 1].push.push(indents);
        }

        function markPop(node, outdents) {
            linesToCheck[node.loc.end.line - 1].pop.push(outdents);
        }

        function markPushAlt(node) {
            linesToCheck[node.loc.start.line - 1].pushAltLine.push(node.loc.end.line - 1);
        }

        function markCase(caseNode, children) {
            var outdentNode = getCaseOutdent(children);

            if (outdentNode) {
                // If a case statement has a `break` as a direct child and it is the
                // first one encountered, use it as the example for all future case indentation
                if (_this._breakIndents === null) {
                    _this._breakIndents = (caseNode.loc.start.column === outdentNode.loc.start.column) ? 1 : 0;
                }
                markPop(outdentNode, _this._breakIndents);
            } else {
                markPop(caseNode, 0);
            }
        }

        function markChildren(node) {
            getChildren(node).forEach(function(childNode) {
                if (childNode.loc.start.line !== node.loc.start.line) {
                    markCheck(childNode);
                }
            });
        }

        function markKeyword(node) {
            if (node) {
                markCheck(file.getPrevToken(file.getFirstNodeToken(node)));
            }
        }

        function isMultiline(node) {
            return node.loc.start.line !== node.loc.end.line;
        }

        function getCaseOutdent(caseChildren) {
            var outdentNode;
            caseChildren.some(function(node) {
                if (node.type === 'BreakStatement') {
                    outdentNode = node;
                    return true;
                }
            });

            return outdentNode;
        }

        function getBlockNodeToPush(node) {
            var parent = node.parentNode;

            // The parent of an else is the entire if/else block. To avoid over indenting
            // in the case of a non-block if with a block else, mark push where the else starts,
            // not where the if starts!
            if (parent.type === 'IfStatement' && parent.alternate === node) {
                return node;
            }

            // The end line to check of a do while statement needs to be the location of the
            // closing curly brace, not the while statement, to avoid marking the last line of
            // a multiline while as a line to check.
            if (parent.type === 'DoWhileStatement') {
                return node;
            }

            // Detect bare blocks: a block whose parent doesn't expect blocks in its syntax specifically.
            if (blockParents.indexOf(parent.type) === -1) {
                return node;
            }

            return parent;
        }

        function getChildren(node) {
            var childrenProperty = indentableNodes[node.type];
            return node[childrenProperty];
        }

        function getIndentationFromLine(line) {
            var rNotIndentChar = new RegExp('[^' + indentChar + ']');
            var firstContent = line.search(rNotIndentChar);
            if (firstContent === -1) {
                firstContent = line.length;
            }
            return firstContent;
        }

        function checkIndentations() {
            var lineAugment = 0;

            linesToCheck.forEach(function(line, i) {
                var lineNumber = i + 1;
                var actualIndentation = line.indentation;
                var expectedIndentation = getExpectedIndentation(line, actualIndentation);

                // do not augment this line considering this line changes indentation
                if (line.pop.length || line.push.length) {
                    lineAugment = 0;
                }

                if (line.check) {
                    errors.assert.indentation({
                        lineNumber: lineNumber,
                        actual: actualIndentation,
                        expected: expectedIndentation,
                        indentChar: indentChar
                    });

                    // for multiline statements, we need move subsequent lines over the correct
                    // number of spaces to match the change made to the first line of the statement.
                    lineAugment = expectedIndentation - actualIndentation;

                    // correct the indentation so that future lines can be validated appropriately
                    actualIndentation = expectedIndentation;
                } else if (!line.empty) {
                    // in the case that we moved a previous line over a certain number spaces,
                    // we need to move this line over as well, but technically, it's not an error
                    errors.assert.indentation({
                        lineNumber: lineNumber,
                        actual: actualIndentation,
                        // Avoid going negative in the case that a previous line was overindented,
                        // and now outdenting a line that is already at column zero.
                        expected: Math.max(actualIndentation + lineAugment, 0),
                        indentChar: indentChar,
                        silent: true
                    });
                }

                if (line.push.length) {
                    pushExpectedIndentations(line, actualIndentation);
                }
            });
        }

        function getExpectedIndentation(line, actual) {
            var outdent = indentSize * Math.max.apply(null, line.pop);

            var idx = indentStack.length - 1;
            var expected = indentStack[idx];

            if (!Array.isArray(expected)) {
                expected = [expected];
            }

            expected = expected.map(function(value) {
                if (line.pop.length) {
                    value -= outdent;
                }

                return value;
            }).reduce(function(previous, current) {
                // when the expected is an array, resolve the value
                // back into a Number by checking both values are the actual indentation
                return actual === current ? current : previous;
            });

            indentStack[idx] = expected;

            line.pop.forEach(function() {
                indentStack.pop();
            });

            return expected;
        }

        function pushExpectedIndentations(line, actualIndentation) {
            var indents = Math.max.apply(null, line.push);

            var expected = actualIndentation + (indentSize * indents);

            // when a line has alternate indentations, push an array of possible values
            // on the stack, to be resolved when checked against an actual indentation
            if (line.pushAltLine.length) {
                expected = [expected];
                line.pushAltLine.forEach(function(altLine) {
                    expected.push(linesToCheck[altLine].indentation + (indentSize * indents));
                });
            }

            line.push.forEach(function() {
                indentStack.push(expected);
            });
        }

        function setModuleBody(node) {
            if (node.body.length !== 1 || node.body[0].type !== 'ExpressionStatement' ||
                node.body[0].expression.type !== 'CallExpression') {
                return;
            }

            var callExpression = node.body[0].expression;
            var callee = callExpression.callee;
            var callArgs = callExpression.arguments;
            var iffeFunction = utils.getFunctionNodeFromIIFE(callExpression);

            if (iffeFunction) {
                if (callArgs.length === 1 && callArgs[0].type === 'FunctionExpression') {
                    // detect UMD Shim, where the file body is the body of the factory,
                    // which is the sole argument to the IIFE
                    moduleBody = callArgs[0].body;
                } else {
                    // full file IIFE
                    moduleBody = iffeFunction.body;
                }
            }

            // detect require/define
            if (callee.type === 'Identifier' && callee.name.match(/^(require|define)$/)) {
                // the define callback is the *first* functionExpression encountered,
                // as it can be the first, second, or third argument.
                callArgs.some(function(argument) {
                    if (argument.type === 'FunctionExpression') {
                        moduleBody = argument.body;
                        return true;
                    }
                });
            }

            // set number of indents for modules by detecting
            // whether the first statement is indented or not
            if (moduleBody && moduleBody.body.length) {
                _this._moduleIndents = moduleBody.body[0].loc.start.column > 0 ? 1 : 0;
            }
        }

        function generateIndentations() {
            file.iterateNodesByType('Program', function(node) {
                if (!isMultiline(node)) {
                    return;
                }

                setModuleBody(node);
                markChildren(node);
            });

            file.iterateNodesByType('BlockStatement', function(node) {
                if (!isMultiline(node)) {
                    return;
                }

                var indents = node === moduleBody ? _this._moduleIndents : 1;

                markChildren(node);
                markPop(node, indents);
                markPush(getBlockNodeToPush(node), indents);
                markEndCheck(node);
            });

            file.iterateNodesByType('ObjectExpression', function(node) {
                if (!isMultiline(node)) {
                    return;
                }

                var children = getChildren(node);

                // only check objects that have children and that look like they are trying to adhere
                // to an indentation strategy, i.e. objects that have curly braces on their own lines.
                if (!children.length || node.loc.start.line === children[0].loc.start.line ||
                    node.loc.end.line === children[children.length - 1].loc.end.line) {
                    return;
                }

                markChildren(node);
                markPop(node, 1);
                markPush(node, 1);
                markEndCheck(node);
                markPushAlt(node);
            });

            file.iterateNodesByType('IfStatement', function(node) {
                markKeyword(node.alternate);
            });

            file.iterateNodesByType('TryStatement', function(node) {
                if (!isMultiline(node)) {
                    return;
                }

                var handler = node.handlers && node.handlers.length ? node.handlers[0] : node.handler;
                if (handler) {
                    markCheck(handler);
                }
                markKeyword(node.finalizer);
            });

            file.iterateNodesByType('SwitchStatement', function(node) {
                if (!isMultiline(node)) {
                    return;
                }

                var indents = 1;
                var children = getChildren(node);

                if (node.loc.start.column === children[0].loc.start.column) {
                    indents = 0;
                }

                markChildren(node);
                markPop(node, indents);
                markPush(node, indents);
                markEndCheck(node);
            });

            file.iterateNodesByType('SwitchCase', function(node) {
                if (!isMultiline(node)) {
                    return;
                }

                var children = getChildren(node);

                if (children.length === 1 && children[0].type === 'BlockStatement') {
                    return;
                }

                markPush(node, 1);
                markCheck(node);
                markChildren(node);

                markCase(node, children);
            });

            // indentations inside of function expressions can be offset from
            // either the start of the function or the end of the function, therefore
            // mark all starting lines of functions as potential indentations
            file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {
                markPushAlt(node);
            });

            if (_this._includeEmptyLines) {
                linesToCheck.forEach(function(line) {
                    if (line.empty) {
                        line.check = true;
                    }
                });
            }

            // starting from the bottom, which allows back to back comments to be checked, mark comments
            file.getComments().concat().reverse().forEach(function(node) {
                var startLine = node.loc.start.line;
                var firstToken = file.getFirstTokenOnLine(startLine, {includeComments: true});

                var nextToken = file.getNextToken(firstToken, {includeComments: true});
                var nextStartLine = nextToken.loc.start.line;

                var nextLine = linesToCheck[nextStartLine - 1];

                // ignore if not the only token on the line, or not right above another checked line
                if (firstToken !== node || startLine === nextStartLine || !nextLine.check) {
                    return;
                }

                // ignore if next line is a case statement, which is kind of hacky, but avoids
                // additional complexity for what qualifies as an outdent
                if (nextToken && nextToken.type === 'Keyword' &&
                    (nextToken.value === 'case' || nextToken.value === 'default')) {
                    return;
                }

                // ignore if above a line that both introduces and ends an ident,
                // which catches cases like a comment above an `else if`, but not nested ifs.
                if (nextLine.push.length && nextLine.pop.length) {
                    return;
                }

                markCheck(node);
            });
        }

        var _this = this;

        var moduleBody;

        var indentChar = this._indentChar;
        var indentSize = this._indentSize;

        var indentStack = [0];
        var linesToCheck = file.getLines().map(function(line) {
            return {
                push: [],
                pushAltLine: [],
                pop: [],
                check: false,
                indentation: getIndentationFromLine(line),
                empty: line.match(/^\s*$/)
            };
        });

        generateIndentations();
        checkIndentations();
    }
    check: function(file, errors) {
Function markCheckLine
✓ Was called        function markCheckLine(line) {···
            linesToCheck[line].check = true;
        }
        function markCheckLine(line) {
            linesToCheck[line].check = true;
        }
Function markCheck
✓ Was called        function markCheck(node) {···
            markCheckLine(node.loc.start.line - 1);
        }
        function markCheck(node) {
            markCheckLine(node.loc.start.line - 1);
        }
Function markEndCheck
✓ Was called        function markEndCheck(node) {···
            markCheckLine(node.loc.end.line - 1);
        }
        function markEndCheck(node) {
            markCheckLine(node.loc.end.line - 1);
        }
Function markPush
✓ Was called        function markPush(node, indents) {···
            linesToCheck[node.loc.start.line - 1].push.push(indents);
        }
        function markPush(node, indents) {
            linesToCheck[node.loc.start.line - 1].push.push(indents);
        }
Function markPop
✓ Was called        function markPop(node, outdents) {···
            linesToCheck[node.loc.end.line - 1].pop.push(outdents);
        }
        function markPop(node, outdents) {
            linesToCheck[node.loc.end.line - 1].pop.push(outdents);
        }
Function markPushAlt
✓ Was called        function markPushAlt(node) {···
            linesToCheck[node.loc.start.line - 1].pushAltLine.push(node.loc.end.line - 1);
        }
        function markPushAlt(node) {
            linesToCheck[node.loc.start.line - 1].pushAltLine.push(node.loc.end.line - 1);
        }
Function markCase
✓ Was called        function markCase(caseNode, children) {···
            var outdentNode = getCaseOutdent(children);

            if (outdentNode) {
                // If a case statement has a `break` as a direct child and it is the
                // first one encountered, use it as the example for all future case indentation
                if (_this._breakIndents === null) {
                    _this._breakIndents = (caseNode.loc.start.column === outdentNode.loc.start.column) ? 1 : 0;
                }
                markPop(outdentNode, _this._breakIndents);
            } else {
                markPop(caseNode, 0);
            }
        }
        function markCase(caseNode, children) {
            var outdentNode = getCaseOutdent(children);
Branch IfStatement
✓ Positive was executed (if)            if (outdentNode) {···
                // If a case statement has a `break` as a direct child and it is the
                // first one encountered, use it as the example for all future case indentation
                if (_this._breakIndents === null) {
                    _this._breakIndents = (caseNode.loc.start.column === outdentNode.loc.start.column) ? 1 : 0;
                }
                markPop(outdentNode, _this._breakIndents);
            } else {
✓ Negative was executed (else)            } else {···
                markPop(caseNode, 0);
            }
            if (outdentNode) {
                // If a case statement has a `break` as a direct child and it is the
                // first one encountered, use it as the example for all future case indentation
Branch IfStatement
✓ Positive was executed (if)                if (_this._breakIndents === null) {···
                    _this._breakIndents = (caseNode.loc.start.column === outdentNode.loc.start.column) ? 1 : 0;
                }
✓ Negative was executed (else)                }···
                markPop(outdentNode, _this._breakIndents);
                if (_this._breakIndents === null) {
Branch ConditionalExpression
✓ Positive was returned (? ...)                    _this._breakIndents = (caseNode.loc.start.column === outdentNode.loc.start.column) ? 1 : 0;
✓ Negative was returned (: ...)                    _this._breakIndents = (caseNode.loc.start.column === outdentNode.loc.start.column) ? 1 : 0;
                    _this._breakIndents = (caseNode.loc.start.column === outdentNode.loc.start.column) ? 1 : 0;
                }
                markPop(outdentNode, _this._breakIndents);
            } else {
                markPop(caseNode, 0);
            }
        }
Function markChildren
✓ Was called        function markChildren(node) {···
            getChildren(node).forEach(function(childNode) {
                if (childNode.loc.start.line !== node.loc.start.line) {
                    markCheck(childNode);
                }
            });
        }
        function markChildren(node) {
Function (anonymous_422)
✓ Was called            getChildren(node).forEach(function(childNode) {···
                if (childNode.loc.start.line !== node.loc.start.line) {
                    markCheck(childNode);
                }
            });
            getChildren(node).forEach(function(childNode) {
Branch IfStatement
✓ Positive was executed (if)                if (childNode.loc.start.line !== node.loc.start.line) {···
                    markCheck(childNode);
                }
✓ Negative was executed (else)                }···
            });
                if (childNode.loc.start.line !== node.loc.start.line) {
                    markCheck(childNode);
                }
            });
        }
Function markKeyword
✓ Was called        function markKeyword(node) {···
            if (node) {
                markCheck(file.getPrevToken(file.getFirstNodeToken(node)));
            }
        }
        function markKeyword(node) {
Branch IfStatement
✓ Positive was executed (if)            if (node) {···
                markCheck(file.getPrevToken(file.getFirstNodeToken(node)));
            }
✓ Negative was executed (else)            }···
        }
            if (node) {
                markCheck(file.getPrevToken(file.getFirstNodeToken(node)));
            }
        }
Function isMultiline
✓ Was called        function isMultiline(node) {···
            return node.loc.start.line !== node.loc.end.line;
        }
        function isMultiline(node) {
            return node.loc.start.line !== node.loc.end.line;
        }
Function getCaseOutdent
✓ Was called        function getCaseOutdent(caseChildren) {···
            var outdentNode;
            caseChildren.some(function(node) {
                if (node.type === 'BreakStatement') {
                    outdentNode = node;
                    return true;
                }
            });

            return outdentNode;
        }
        function getCaseOutdent(caseChildren) {
            var outdentNode;
Function (anonymous_426)
✓ Was called            caseChildren.some(function(node) {···
                if (node.type === 'BreakStatement') {
                    outdentNode = node;
                    return true;
                }
            });
            caseChildren.some(function(node) {
Branch IfStatement
✓ Positive was executed (if)                if (node.type === 'BreakStatement') {···
                    outdentNode = node;
                    return true;
                }
✓ Negative was executed (else)                }···
            });
                if (node.type === 'BreakStatement') {
                    outdentNode = node;
                    return true;
                }
            });
            return outdentNode;
        }
Function getBlockNodeToPush
✓ Was called        function getBlockNodeToPush(node) {···
            var parent = node.parentNode;

            // The parent of an else is the entire if/else block. To avoid over indenting
            // in the case of a non-block if with a block else, mark push where the else starts,
            // not where the if starts!
            if (parent.type === 'IfStatement' && parent.alternate === node) {
                return node;
            }

            // The end line to check of a do while statement needs to be the location of the
            // closing curly brace, not the while statement, to avoid marking the last line of
            // a multiline while as a line to check.
            if (parent.type === 'DoWhileStatement') {
                return node;
            }

            // Detect bare blocks: a block whose parent doesn't expect blocks in its syntax specifically.
            if (blockParents.indexOf(parent.type) === -1) {
                return node;
            }

            return parent;
        }
        function getBlockNodeToPush(node) {
            var parent = node.parentNode;
            // The parent of an else is the entire if/else block. To avoid over indenting
            // in the case of a non-block if with a block else, mark push where the else starts,
            // not where the if starts!
Branch IfStatement
✓ Positive was executed (if)            if (parent.type === 'IfStatement' && parent.alternate === node) {···
                return node;
            }
✓ Negative was executed (else)            }···

            // The end line to check of a do while statement needs to be the location of the
Branch LogicalExpression
✓ Was returned            if (parent.type === 'IfStatement' && parent.alternate === node) {
✓ Was returned            if (parent.type === 'IfStatement' && parent.alternate === node) {
            if (parent.type === 'IfStatement' && parent.alternate === node) {
                return node;
            }
            // The end line to check of a do while statement needs to be the location of the
            // closing curly brace, not the while statement, to avoid marking the last line of
            // a multiline while as a line to check.
Branch IfStatement
✓ Positive was executed (if)            if (parent.type === 'DoWhileStatement') {···
                return node;
            }
✓ Negative was executed (else)            }···

            // Detect bare blocks: a block whose parent doesn't expect blocks in its syntax specifically.
            if (parent.type === 'DoWhileStatement') {
                return node;
            }
            // Detect bare blocks: a block whose parent doesn't expect blocks in its syntax specifically.
Branch IfStatement
✓ Positive was executed (if)            if (blockParents.indexOf(parent.type) === -1) {···
                return node;
            }
✓ Negative was executed (else)            }···

            return parent;
            if (blockParents.indexOf(parent.type) === -1) {
                return node;
            }
            return parent;
        }
Function getChildren
✓ Was called        function getChildren(node) {···
            var childrenProperty = indentableNodes[node.type];
            return node[childrenProperty];
        }
        function getChildren(node) {
            var childrenProperty = indentableNodes[node.type];
            return node[childrenProperty];
        }
Function getIndentationFromLine
✓ Was called        function getIndentationFromLine(line) {···
            var rNotIndentChar = new RegExp('[^' + indentChar + ']');
            var firstContent = line.search(rNotIndentChar);
            if (firstContent === -1) {
                firstContent = line.length;
            }
            return firstContent;
        }
        function getIndentationFromLine(line) {
            var rNotIndentChar = new RegExp('[^' + indentChar + ']');
            var firstContent = line.search(rNotIndentChar);
Branch IfStatement
✓ Positive was executed (if)            if (firstContent === -1) {···
                firstContent = line.length;
            }
✓ Negative was executed (else)            }···
            return firstContent;
            if (firstContent === -1) {
                firstContent = line.length;
            }
            return firstContent;
        }
Function checkIndentations
✓ Was called        function checkIndentations() {···
            var lineAugment = 0;

            linesToCheck.forEach(function(line, i) {
                var lineNumber = i + 1;
                var actualIndentation = line.indentation;
                var expectedIndentation = getExpectedIndentation(line, actualIndentation);

                // do not augment this line considering this line changes indentation
                if (line.pop.length || line.push.length) {
                    lineAugment = 0;
                }

                if (line.check) {
                    errors.assert.indentation({
                        lineNumber: lineNumber,
                        actual: actualIndentation,
                        expected: expectedIndentation,
                        indentChar: indentChar
                    });

                    // for multiline statements, we need move subsequent lines over the correct
                    // number of spaces to match the change made to the first line of the statement.
                    lineAugment = expectedIndentation - actualIndentation;

                    // correct the indentation so that future lines can be validated appropriately
                    actualIndentation = expectedIndentation;
                } else if (!line.empty) {
                    // in the case that we moved a previous line over a certain number spaces,
                    // we need to move this line over as well, but technically, it's not an error
                    errors.assert.indentation({
                        lineNumber: lineNumber,
                        actual: actualIndentation,
                        // Avoid going negative in the case that a previous line was overindented,
                        // and now outdenting a line that is already at column zero.
                        expected: Math.max(actualIndentation + lineAugment, 0),
                        indentChar: indentChar,
                        silent: true
                    });
                }

                if (line.push.length) {
                    pushExpectedIndentations(line, actualIndentation);
                }
            });
        }
        function checkIndentations() {
            var lineAugment = 0;
Function (anonymous_431)
✓ Was called            linesToCheck.forEach(function(line, i) {···
                var lineNumber = i + 1;
                var actualIndentation = line.indentation;
                var expectedIndentation = getExpectedIndentation(line, actualIndentation);

                // do not augment this line considering this line changes indentation
                if (line.pop.length || line.push.length) {
                    lineAugment = 0;
                }

                if (line.check) {
                    errors.assert.indentation({
                        lineNumber: lineNumber,
                        actual: actualIndentation,
                        expected: expectedIndentation,
                        indentChar: indentChar
                    });

                    // for multiline statements, we need move subsequent lines over the correct
                    // number of spaces to match the change made to the first line of the statement.
                    lineAugment = expectedIndentation - actualIndentation;

                    // correct the indentation so that future lines can be validated appropriately
                    actualIndentation = expectedIndentation;
                } else if (!line.empty) {
                    // in the case that we moved a previous line over a certain number spaces,
                    // we need to move this line over as well, but technically, it's not an error
                    errors.assert.indentation({
                        lineNumber: lineNumber,
                        actual: actualIndentation,
                        // Avoid going negative in the case that a previous line was overindented,
                        // and now outdenting a line that is already at column zero.
                        expected: Math.max(actualIndentation + lineAugment, 0),
                        indentChar: indentChar,
                        silent: true
                    });
                }

                if (line.push.length) {
                    pushExpectedIndentations(line, actualIndentation);
                }
            });
            linesToCheck.forEach(function(line, i) {
                var lineNumber = i + 1;
                var actualIndentation = line.indentation;
                var expectedIndentation = getExpectedIndentation(line, actualIndentation);
                // do not augment this line considering this line changes indentation
Branch IfStatement
✓ Positive was executed (if)                if (line.pop.length || line.push.length) {···
                    lineAugment = 0;
                }
✓ Negative was executed (else)                }···

                if (line.check) {
Branch LogicalExpression
✓ Was returned                if (line.pop.length || line.push.length) {
✓ Was returned                if (line.pop.length || line.push.length) {
                if (line.pop.length || line.push.length) {
                    lineAugment = 0;
                }
Branch IfStatement
✓ Positive was executed (if)                if (line.check) {···
                    errors.assert.indentation({
                        lineNumber: lineNumber,
                        actual: actualIndentation,
                        expected: expectedIndentation,
                        indentChar: indentChar
                    });

                    // for multiline statements, we need move subsequent lines over the correct
                    // number of spaces to match the change made to the first line of the statement.
                    lineAugment = expectedIndentation - actualIndentation;

                    // correct the indentation so that future lines can be validated appropriately
                    actualIndentation = expectedIndentation;
                } else if (!line.empty) {
✓ Negative was executed (else)                } else if (!line.empty) {···
                    // in the case that we moved a previous line over a certain number spaces,
                    // we need to move this line over as well, but technically, it's not an error
                    errors.assert.indentation({
                        lineNumber: lineNumber,
                        actual: actualIndentation,
                        // Avoid going negative in the case that a previous line was overindented,
                        // and now outdenting a line that is already at column zero.
                        expected: Math.max(actualIndentation + lineAugment, 0),
                        indentChar: indentChar,
                        silent: true
                    });
                }
                if (line.check) {
                    errors.assert.indentation({
                        lineNumber: lineNumber,
                        actual: actualIndentation,
                        expected: expectedIndentation,
                        indentChar: indentChar
                    });
                    // for multiline statements, we need move subsequent lines over the correct
                    // number of spaces to match the change made to the first line of the statement.
                    lineAugment = expectedIndentation - actualIndentation;
                    // correct the indentation so that future lines can be validated appropriately
                    actualIndentation = expectedIndentation;
Branch IfStatement
✓ Positive was executed (if)                } else if (!line.empty) {···
                    // in the case that we moved a previous line over a certain number spaces,
                    // we need to move this line over as well, but technically, it's not an error
                    errors.assert.indentation({
                        lineNumber: lineNumber,
                        actual: actualIndentation,
                        // Avoid going negative in the case that a previous line was overindented,
                        // and now outdenting a line that is already at column zero.
                        expected: Math.max(actualIndentation + lineAugment, 0),
                        indentChar: indentChar,
                        silent: true
                    });
                }
✓ Negative was executed (else)                }···

                if (line.push.length) {
                } else if (!line.empty) {
                    // in the case that we moved a previous line over a certain number spaces,
                    // we need to move this line over as well, but technically, it's not an error
                    errors.assert.indentation({
                        lineNumber: lineNumber,
                        actual: actualIndentation,
                        // Avoid going negative in the case that a previous line was overindented,
                        // and now outdenting a line that is already at column zero.
                        expected: Math.max(actualIndentation + lineAugment, 0),
                        indentChar: indentChar,
                        silent: true
                    });
                }
Branch IfStatement
✓ Positive was executed (if)                if (line.push.length) {···
                    pushExpectedIndentations(line, actualIndentation);
                }
✓ Negative was executed (else)                }···
            });
                if (line.push.length) {
                    pushExpectedIndentations(line, actualIndentation);
                }
            });
        }
Function getExpectedIndentation
✓ Was called        function getExpectedIndentation(line, actual) {···
            var outdent = indentSize * Math.max.apply(null, line.pop);

            var idx = indentStack.length - 1;
            var expected = indentStack[idx];

            if (!Array.isArray(expected)) {
                expected = [expected];
            }

            expected = expected.map(function(value) {
                if (line.pop.length) {
                    value -= outdent;
                }

                return value;
            }).reduce(function(previous, current) {
                // when the expected is an array, resolve the value
                // back into a Number by checking both values are the actual indentation
                return actual === current ? current : previous;
            });

            indentStack[idx] = expected;

            line.pop.forEach(function() {
                indentStack.pop();
            });

            return expected;
        }
        function getExpectedIndentation(line, actual) {
            var outdent = indentSize * Math.max.apply(null, line.pop);
            var idx = indentStack.length - 1;
            var expected = indentStack[idx];
Branch IfStatement
✓ Positive was executed (if)            if (!Array.isArray(expected)) {···
                expected = [expected];
            }
✓ Negative was executed (else)            }···

            expected = expected.map(function(value) {
            if (!Array.isArray(expected)) {
                expected = [expected];
            }
Function (anonymous_433)
✓ Was called            expected = expected.map(function(value) {···
                if (line.pop.length) {
                    value -= outdent;
                }

                return value;
            }).reduce(function(previous, current) {
            expected = expected.map(function(value) {
Branch IfStatement
✓ Positive was executed (if)                if (line.pop.length) {···
                    value -= outdent;
                }
✓ Negative was executed (else)                }···

                return value;
                if (line.pop.length) {
                    value -= outdent;
                }
                return value;
Function (anonymous_434)
✓ Was called            }).reduce(function(previous, current) {···
                // when the expected is an array, resolve the value
                // back into a Number by checking both values are the actual indentation
                return actual === current ? current : previous;
            });
            }).reduce(function(previous, current) {
                // when the expected is an array, resolve the value
                // back into a Number by checking both values are the actual indentation
Branch ConditionalExpression
✓ Positive was returned (? ...)                return actual === current ? current : previous;
✓ Negative was returned (: ...)                return actual === current ? current : previous;
                return actual === current ? current : previous;
            });
            indentStack[idx] = expected;
Function (anonymous_435)
✓ Was called            line.pop.forEach(function() {···
                indentStack.pop();
            });
            line.pop.forEach(function() {
                indentStack.pop();
            });
            return expected;
        }
Function pushExpectedIndentations
✓ Was called        function pushExpectedIndentations(line, actualIndentation) {···
            var indents = Math.max.apply(null, line.push);

            var expected = actualIndentation + (indentSize * indents);

            // when a line has alternate indentations, push an array of possible values
            // on the stack, to be resolved when checked against an actual indentation
            if (line.pushAltLine.length) {
                expected = [expected];
                line.pushAltLine.forEach(function(altLine) {
                    expected.push(linesToCheck[altLine].indentation + (indentSize * indents));
                });
            }

            line.push.forEach(function() {
                indentStack.push(expected);
            });
        }
        function pushExpectedIndentations(line, actualIndentation) {
            var indents = Math.max.apply(null, line.push);
            var expected = actualIndentation + (indentSize * indents);
            // when a line has alternate indentations, push an array of possible values
            // on the stack, to be resolved when checked against an actual indentation
Branch IfStatement
✓ Positive was executed (if)            if (line.pushAltLine.length) {···
                expected = [expected];
                line.pushAltLine.forEach(function(altLine) {
                    expected.push(linesToCheck[altLine].indentation + (indentSize * indents));
                });
            }
✓ Negative was executed (else)            }···

            line.push.forEach(function() {
            if (line.pushAltLine.length) {
                expected = [expected];
Function (anonymous_437)
✓ Was called                line.pushAltLine.forEach(function(altLine) {···
                    expected.push(linesToCheck[altLine].indentation + (indentSize * indents));
                });
                line.pushAltLine.forEach(function(altLine) {
                    expected.push(linesToCheck[altLine].indentation + (indentSize * indents));
                });
            }
Function (anonymous_438)
✓ Was called            line.push.forEach(function() {···
                indentStack.push(expected);
            });
            line.push.forEach(function() {
                indentStack.push(expected);
            });
        }
Function setModuleBody
✓ Was called        function setModuleBody(node) {···
            if (node.body.length !== 1 || node.body[0].type !== 'ExpressionStatement' ||
                node.body[0].expression.type !== 'CallExpression') {
                return;
            }

            var callExpression = node.body[0].expression;
            var callee = callExpression.callee;
            var callArgs = callExpression.arguments;
            var iffeFunction = utils.getFunctionNodeFromIIFE(callExpression);

            if (iffeFunction) {
                if (callArgs.length === 1 && callArgs[0].type === 'FunctionExpression') {
                    // detect UMD Shim, where the file body is the body of the factory,
                    // which is the sole argument to the IIFE
                    moduleBody = callArgs[0].body;
                } else {
                    // full file IIFE
                    moduleBody = iffeFunction.body;
                }
            }

            // detect require/define
            if (callee.type === 'Identifier' && callee.name.match(/^(require|define)$/)) {
                // the define callback is the *first* functionExpression encountered,
                // as it can be the first, second, or third argument.
                callArgs.some(function(argument) {
                    if (argument.type === 'FunctionExpression') {
                        moduleBody = argument.body;
                        return true;
                    }
                });
            }

            // set number of indents for modules by detecting
            // whether the first statement is indented or not
            if (moduleBody && moduleBody.body.length) {
                _this._moduleIndents = moduleBody.body[0].loc.start.column > 0 ? 1 : 0;
            }
        }
        function setModuleBody(node) {
Branch IfStatement
✓ Positive was executed (if)                node.body[0].expression.type !== 'CallExpression') {···
                return;
            }
✓ Negative was executed (else)            }···

            var callExpression = node.body[0].expression;
Branch LogicalExpression
✓ Was returned                node.body[0].expression.type !== 'CallExpression') {
✓ Was returned            if (node.body.length !== 1 || node.body[0].type !== 'ExpressionStatement' ||
Branch LogicalExpression
✓ Was returned            if (node.body.length !== 1 || node.body[0].type !== 'ExpressionStatement' ||
✓ Was returned            if (node.body.length !== 1 || node.body[0].type !== 'ExpressionStatement' ||
            if (node.body.length !== 1 || node.body[0].type !== 'ExpressionStatement' ||
                node.body[0].expression.type !== 'CallExpression') {
                return;
            }
            var callExpression = node.body[0].expression;
            var callee = callExpression.callee;
            var callArgs = callExpression.arguments;
            var iffeFunction = utils.getFunctionNodeFromIIFE(callExpression);
Branch IfStatement
✓ Positive was executed (if)            if (iffeFunction) {···
                if (callArgs.length === 1 && callArgs[0].type === 'FunctionExpression') {
                    // detect UMD Shim, where the file body is the body of the factory,
                    // which is the sole argument to the IIFE
                    moduleBody = callArgs[0].body;
                } else {
                    // full file IIFE
                    moduleBody = iffeFunction.body;
                }
            }
✓ Negative was executed (else)            }···

            // detect require/define
            if (iffeFunction) {
Branch IfStatement
✓ Positive was executed (if)                if (callArgs.length === 1 && callArgs[0].type === 'FunctionExpression') {···
                    // detect UMD Shim, where the file body is the body of the factory,
                    // which is the sole argument to the IIFE
                    moduleBody = callArgs[0].body;
                } else {
✓ Negative was executed (else)                } else {···
                    // full file IIFE
                    moduleBody = iffeFunction.body;
                }
Branch LogicalExpression
✓ Was returned                if (callArgs.length === 1 && callArgs[0].type === 'FunctionExpression') {
✗ Was not returned                if (callArgs.length === 1 && callArgs[0].type === 'FunctionExpression') {
                if (callArgs.length === 1 && callArgs[0].type === 'FunctionExpression') {
                    // detect UMD Shim, where the file body is the body of the factory,
                    // which is the sole argument to the IIFE
                    moduleBody = callArgs[0].body;
                } else {
                    // full file IIFE
                    moduleBody = iffeFunction.body;
                }
            }
            // detect require/define
Branch IfStatement
✓ Positive was executed (if)            if (callee.type === 'Identifier' && callee.name.match(/^(require|define)$/)) {···
                // the define callback is the *first* functionExpression encountered,
                // as it can be the first, second, or third argument.
                callArgs.some(function(argument) {
                    if (argument.type === 'FunctionExpression') {
                        moduleBody = argument.body;
                        return true;
                    }
                });
            }
✓ Negative was executed (else)            }···

            // set number of indents for modules by detecting
Branch LogicalExpression
✓ Was returned            if (callee.type === 'Identifier' && callee.name.match(/^(require|define)$/)) {
✓ Was returned            if (callee.type === 'Identifier' && callee.name.match(/^(require|define)$/)) {
            if (callee.type === 'Identifier' && callee.name.match(/^(require|define)$/)) {
                // the define callback is the *first* functionExpression encountered,
                // as it can be the first, second, or third argument.
Function (anonymous_440)
✓ Was called                callArgs.some(function(argument) {···
                    if (argument.type === 'FunctionExpression') {
                        moduleBody = argument.body;
                        return true;
                    }
                });
                callArgs.some(function(argument) {
Branch IfStatement
✓ Positive was executed (if)                    if (argument.type === 'FunctionExpression') {···
                        moduleBody = argument.body;
                        return true;
                    }
✓ Negative was executed (else)                    }···
                });
                    if (argument.type === 'FunctionExpression') {
                        moduleBody = argument.body;
                        return true;
                    }
                });
            }
            // set number of indents for modules by detecting
            // whether the first statement is indented or not
Branch IfStatement
✓ Positive was executed (if)            if (moduleBody && moduleBody.body.length) {···
                _this._moduleIndents = moduleBody.body[0].loc.start.column > 0 ? 1 : 0;
            }
✓ Negative was executed (else)            }···
        }
Branch LogicalExpression
✓ Was returned            if (moduleBody && moduleBody.body.length) {
✓ Was returned            if (moduleBody && moduleBody.body.length) {
            if (moduleBody && moduleBody.body.length) {
Branch ConditionalExpression
✓ Positive was returned (? ...)                _this._moduleIndents = moduleBody.body[0].loc.start.column > 0 ? 1 : 0;
✓ Negative was returned (: ...)                _this._moduleIndents = moduleBody.body[0].loc.start.column > 0 ? 1 : 0;
                _this._moduleIndents = moduleBody.body[0].loc.start.column > 0 ? 1 : 0;
            }
        }
Function generateIndentations
✓ Was called        function generateIndentations() {···
            file.iterateNodesByType('Program', function(node) {
                if (!isMultiline(node)) {
                    return;
                }

                setModuleBody(node);
                markChildren(node);
            });

            file.iterateNodesByType('BlockStatement', function(node) {
                if (!isMultiline(node)) {
                    return;
                }

                var indents = node === moduleBody ? _this._moduleIndents : 1;

                markChildren(node);
                markPop(node, indents);
                markPush(getBlockNodeToPush(node), indents);
                markEndCheck(node);
            });

            file.iterateNodesByType('ObjectExpression', function(node) {
                if (!isMultiline(node)) {
                    return;
                }

                var children = getChildren(node);

                // only check objects that have children and that look like they are trying to adhere
                // to an indentation strategy, i.e. objects that have curly braces on their own lines.
                if (!children.length || node.loc.start.line === children[0].loc.start.line ||
                    node.loc.end.line === children[children.length - 1].loc.end.line) {
                    return;
                }

                markChildren(node);
                markPop(node, 1);
                markPush(node, 1);
                markEndCheck(node);
                markPushAlt(node);
            });

            file.iterateNodesByType('IfStatement', function(node) {
                markKeyword(node.alternate);
            });

            file.iterateNodesByType('TryStatement', function(node) {
                if (!isMultiline(node)) {
                    return;
                }

                var handler = node.handlers && node.handlers.length ? node.handlers[0] : node.handler;
                if (handler) {
                    markCheck(handler);
                }
                markKeyword(node.finalizer);
            });

            file.iterateNodesByType('SwitchStatement', function(node) {
                if (!isMultiline(node)) {
                    return;
                }

                var indents = 1;
                var children = getChildren(node);

                if (node.loc.start.column === children[0].loc.start.column) {
                    indents = 0;
                }

                markChildren(node);
                markPop(node, indents);
                markPush(node, indents);
                markEndCheck(node);
            });

            file.iterateNodesByType('SwitchCase', function(node) {
                if (!isMultiline(node)) {
                    return;
                }

                var children = getChildren(node);

                if (children.length === 1 && children[0].type === 'BlockStatement') {
                    return;
                }

                markPush(node, 1);
                markCheck(node);
                markChildren(node);

                markCase(node, children);
            });

            // indentations inside of function expressions can be offset from
            // either the start of the function or the end of the function, therefore
            // mark all starting lines of functions as potential indentations
            file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {
                markPushAlt(node);
            });

            if (_this._includeEmptyLines) {
                linesToCheck.forEach(function(line) {
                    if (line.empty) {
                        line.check = true;
                    }
                });
            }

            // starting from the bottom, which allows back to back comments to be checked, mark comments
            file.getComments().concat().reverse().forEach(function(node) {
                var startLine = node.loc.start.line;
                var firstToken = file.getFirstTokenOnLine(startLine, {includeComments: true});

                var nextToken = file.getNextToken(firstToken, {includeComments: true});
                var nextStartLine = nextToken.loc.start.line;

                var nextLine = linesToCheck[nextStartLine - 1];

                // ignore if not the only token on the line, or not right above another checked line
                if (firstToken !== node || startLine === nextStartLine || !nextLine.check) {
                    return;
                }

                // ignore if next line is a case statement, which is kind of hacky, but avoids
                // additional complexity for what qualifies as an outdent
                if (nextToken && nextToken.type === 'Keyword' &&
                    (nextToken.value === 'case' || nextToken.value === 'default')) {
                    return;
                }

                // ignore if above a line that both introduces and ends an ident,
                // which catches cases like a comment above an `else if`, but not nested ifs.
                if (nextLine.push.length && nextLine.pop.length) {
                    return;
                }

                markCheck(node);
            });
        }
        function generateIndentations() {
Function (anonymous_442)
✓ Was called            file.iterateNodesByType('Program', function(node) {···
                if (!isMultiline(node)) {
                    return;
                }

                setModuleBody(node);
                markChildren(node);
            });
            file.iterateNodesByType('Program', function(node) {
Branch IfStatement
✓ Positive was executed (if)                if (!isMultiline(node)) {···
                    return;
                }
✓ Negative was executed (else)                }···

                setModuleBody(node);
                if (!isMultiline(node)) {
                    return;
                }
                setModuleBody(node);
                markChildren(node);
            });
Function (anonymous_443)
✓ Was called            file.iterateNodesByType('BlockStatement', function(node) {···
                if (!isMultiline(node)) {
                    return;
                }

                var indents = node === moduleBody ? _this._moduleIndents : 1;

                markChildren(node);
                markPop(node, indents);
                markPush(getBlockNodeToPush(node), indents);
                markEndCheck(node);
            });
            file.iterateNodesByType('BlockStatement', function(node) {
Branch IfStatement
✓ Positive was executed (if)                if (!isMultiline(node)) {···
                    return;
                }
✓ Negative was executed (else)                }···

                var indents = node === moduleBody ? _this._moduleIndents : 1;
                if (!isMultiline(node)) {
                    return;
                }
Branch ConditionalExpression
✓ Positive was returned (? ...)                var indents = node === moduleBody ? _this._moduleIndents : 1;
✓ Negative was returned (: ...)                var indents = node === moduleBody ? _this._moduleIndents : 1;
                var indents = node === moduleBody ? _this._moduleIndents : 1;
                markChildren(node);
                markPop(node, indents);
                markPush(getBlockNodeToPush(node), indents);
                markEndCheck(node);
            });
Function (anonymous_444)
✓ Was called            file.iterateNodesByType('ObjectExpression', function(node) {···
                if (!isMultiline(node)) {
                    return;
                }

                var children = getChildren(node);

                // only check objects that have children and that look like they are trying to adhere
                // to an indentation strategy, i.e. objects that have curly braces on their own lines.
                if (!children.length || node.loc.start.line === children[0].loc.start.line ||
                    node.loc.end.line === children[children.length - 1].loc.end.line) {
                    return;
                }

                markChildren(node);
                markPop(node, 1);
                markPush(node, 1);
                markEndCheck(node);
                markPushAlt(node);
            });
            file.iterateNodesByType('ObjectExpression', function(node) {
Branch IfStatement
✓ Positive was executed (if)                if (!isMultiline(node)) {···
                    return;
                }
✓ Negative was executed (else)                }···

                var children = getChildren(node);
                if (!isMultiline(node)) {
                    return;
                }
                var children = getChildren(node);
                // only check objects that have children and that look like they are trying to adhere
                // to an indentation strategy, i.e. objects that have curly braces on their own lines.
Branch IfStatement
✓ Positive was executed (if)                    node.loc.end.line === children[children.length - 1].loc.end.line) {···
                    return;
                }
✓ Negative was executed (else)                }···

                markChildren(node);
Branch LogicalExpression
✓ Was returned                    node.loc.end.line === children[children.length - 1].loc.end.line) {
✓ Was returned                if (!children.length || node.loc.start.line === children[0].loc.start.line ||
Branch LogicalExpression
✓ Was returned                if (!children.length || node.loc.start.line === children[0].loc.start.line ||
✗ Was not returned                if (!children.length || node.loc.start.line === children[0].loc.start.line ||
                if (!children.length || node.loc.start.line === children[0].loc.start.line ||
                    node.loc.end.line === children[children.length - 1].loc.end.line) {
                    return;
                }
                markChildren(node);
                markPop(node, 1);
                markPush(node, 1);
                markEndCheck(node);
                markPushAlt(node);
            });
Function (anonymous_445)
✓ Was called            file.iterateNodesByType('IfStatement', function(node) {···
                markKeyword(node.alternate);
            });
            file.iterateNodesByType('IfStatement', function(node) {
                markKeyword(node.alternate);
            });
Function (anonymous_446)
✓ Was called            file.iterateNodesByType('TryStatement', function(node) {···
                if (!isMultiline(node)) {
                    return;
                }

                var handler = node.handlers && node.handlers.length ? node.handlers[0] : node.handler;
                if (handler) {
                    markCheck(handler);
                }
                markKeyword(node.finalizer);
            });
            file.iterateNodesByType('TryStatement', function(node) {
Branch IfStatement
✓ Positive was executed (if)                if (!isMultiline(node)) {···
                    return;
                }
✓ Negative was executed (else)                }···

                var handler = node.handlers && node.handlers.length ? node.handlers[0] : node.handler;
                if (!isMultiline(node)) {
                    return;
                }
Branch ConditionalExpression
✓ Positive was returned (? ...)                var handler = node.handlers && node.handlers.length ? node.handlers[0] : node.handler;
✓ Negative was returned (: ...)                var handler = node.handlers && node.handlers.length ? node.handlers[0] : node.handler;
Branch LogicalExpression
✓ Was returned                var handler = node.handlers && node.handlers.length ? node.handlers[0] : node.handler;
✗ Was not returned                var handler = node.handlers && node.handlers.length ? node.handlers[0] : node.handler;
                var handler = node.handlers && node.handlers.length ? node.handlers[0] : node.handler;
Branch IfStatement
✓ Positive was executed (if)                if (handler) {···
                    markCheck(handler);
                }
✓ Negative was executed (else)                }···
                markKeyword(node.finalizer);
                if (handler) {
                    markCheck(handler);
                }
                markKeyword(node.finalizer);
            });
Function (anonymous_447)
✓ Was called            file.iterateNodesByType('SwitchStatement', function(node) {···
                if (!isMultiline(node)) {
                    return;
                }

                var indents = 1;
                var children = getChildren(node);

                if (node.loc.start.column === children[0].loc.start.column) {
                    indents = 0;
                }

                markChildren(node);
                markPop(node, indents);
                markPush(node, indents);
                markEndCheck(node);
            });
            file.iterateNodesByType('SwitchStatement', function(node) {
Branch IfStatement
✓ Positive was executed (if)                if (!isMultiline(node)) {···
                    return;
                }
✓ Negative was executed (else)                }···

                var indents = 1;
                if (!isMultiline(node)) {
                    return;
                }
                var indents = 1;
                var children = getChildren(node);
Branch IfStatement
✓ Positive was executed (if)                if (node.loc.start.column === children[0].loc.start.column) {···
                    indents = 0;
                }
✓ Negative was executed (else)                }···

                markChildren(node);
                if (node.loc.start.column === children[0].loc.start.column) {
                    indents = 0;
                }
                markChildren(node);
                markPop(node, indents);
                markPush(node, indents);
                markEndCheck(node);
            });
Function (anonymous_448)
✓ Was called            file.iterateNodesByType('SwitchCase', function(node) {···
                if (!isMultiline(node)) {
                    return;
                }

                var children = getChildren(node);

                if (children.length === 1 && children[0].type === 'BlockStatement') {
                    return;
                }

                markPush(node, 1);
                markCheck(node);
                markChildren(node);

                markCase(node, children);
            });
            file.iterateNodesByType('SwitchCase', function(node) {
Branch IfStatement
✓ Positive was executed (if)                if (!isMultiline(node)) {···
                    return;
                }
✓ Negative was executed (else)                }···

                var children = getChildren(node);
                if (!isMultiline(node)) {
                    return;
                }
                var children = getChildren(node);
Branch IfStatement
✓ Positive was executed (if)                if (children.length === 1 && children[0].type === 'BlockStatement') {···
                    return;
                }
✓ Negative was executed (else)                }···

                markPush(node, 1);
Branch LogicalExpression
✓ Was returned                if (children.length === 1 && children[0].type === 'BlockStatement') {
✓ Was returned                if (children.length === 1 && children[0].type === 'BlockStatement') {
                if (children.length === 1 && children[0].type === 'BlockStatement') {
                    return;
                }
                markPush(node, 1);
                markCheck(node);
                markChildren(node);
                markCase(node, children);
            });
            // indentations inside of function expressions can be offset from
            // either the start of the function or the end of the function, therefore
            // mark all starting lines of functions as potential indentations
Function (anonymous_449)
✓ Was called            file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {···
                markPushAlt(node);
            });
            file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {
                markPushAlt(node);
            });
Branch IfStatement
✓ Positive was executed (if)            if (_this._includeEmptyLines) {···
                linesToCheck.forEach(function(line) {
                    if (line.empty) {
                        line.check = true;
                    }
                });
            }
✓ Negative was executed (else)            }···

            // starting from the bottom, which allows back to back comments to be checked, mark comments
            if (_this._includeEmptyLines) {
Function (anonymous_450)
✓ Was called                linesToCheck.forEach(function(line) {···
                    if (line.empty) {
                        line.check = true;
                    }
                });
                linesToCheck.forEach(function(line) {
Branch IfStatement
✓ Positive was executed (if)                    if (line.empty) {···
                        line.check = true;
                    }
✓ Negative was executed (else)                    }···
                });
                    if (line.empty) {
                        line.check = true;
                    }
                });
            }
            // starting from the bottom, which allows back to back comments to be checked, mark comments
Function (anonymous_451)
✓ Was called            file.getComments().concat().reverse().forEach(function(node) {···
                var startLine = node.loc.start.line;
                var firstToken = file.getFirstTokenOnLine(startLine, {includeComments: true});

                var nextToken = file.getNextToken(firstToken, {includeComments: true});
                var nextStartLine = nextToken.loc.start.line;

                var nextLine = linesToCheck[nextStartLine - 1];

                // ignore if not the only token on the line, or not right above another checked line
                if (firstToken !== node || startLine === nextStartLine || !nextLine.check) {
                    return;
                }

                // ignore if next line is a case statement, which is kind of hacky, but avoids
                // additional complexity for what qualifies as an outdent
                if (nextToken && nextToken.type === 'Keyword' &&
                    (nextToken.value === 'case' || nextToken.value === 'default')) {
                    return;
                }

                // ignore if above a line that both introduces and ends an ident,
                // which catches cases like a comment above an `else if`, but not nested ifs.
                if (nextLine.push.length && nextLine.pop.length) {
                    return;
                }

                markCheck(node);
            });
            file.getComments().concat().reverse().forEach(function(node) {
                var startLine = node.loc.start.line;
                var firstToken = file.getFirstTokenOnLine(startLine, {includeComments: true});
                var nextToken = file.getNextToken(firstToken, {includeComments: true});
                var nextStartLine = nextToken.loc.start.line;
                var nextLine = linesToCheck[nextStartLine - 1];
                // ignore if not the only token on the line, or not right above another checked line
Branch IfStatement
✓ Positive was executed (if)                if (firstToken !== node || startLine === nextStartLine || !nextLine.check) {···
                    return;
                }
✓ Negative was executed (else)                }···

                // ignore if next line is a case statement, which is kind of hacky, but avoids
Branch LogicalExpression
✓ Was returned                if (firstToken !== node || startLine === nextStartLine || !nextLine.check) {
✓ Was returned                if (firstToken !== node || startLine === nextStartLine || !nextLine.check) {
Branch LogicalExpression
✓ Was returned                if (firstToken !== node || startLine === nextStartLine || !nextLine.check) {
✓ Was returned                if (firstToken !== node || startLine === nextStartLine || !nextLine.check) {
                if (firstToken !== node || startLine === nextStartLine || !nextLine.check) {
                    return;
                }
                // ignore if next line is a case statement, which is kind of hacky, but avoids
                // additional complexity for what qualifies as an outdent
Branch IfStatement
✓ Positive was executed (if)                    (nextToken.value === 'case' || nextToken.value === 'default')) {···
                    return;
                }
✓ Negative was executed (else)                }···

                // ignore if above a line that both introduces and ends an ident,
Branch LogicalExpression
✓ Was returned                    (nextToken.value === 'case' || nextToken.value === 'default')) {
✓ Was returned                if (nextToken && nextToken.type === 'Keyword' &&
Branch LogicalExpression
✓ Was returned                if (nextToken && nextToken.type === 'Keyword' &&
✗ Was not returned                if (nextToken && nextToken.type === 'Keyword' &&
                if (nextToken && nextToken.type === 'Keyword' &&
Branch LogicalExpression
✓ Was returned                    (nextToken.value === 'case' || nextToken.value === 'default')) {
✓ Was returned                    (nextToken.value === 'case' || nextToken.value === 'default')) {
                    (nextToken.value === 'case' || nextToken.value === 'default')) {
                    return;
                }
                // ignore if above a line that both introduces and ends an ident,
                // which catches cases like a comment above an `else if`, but not nested ifs.
Branch IfStatement
✓ Positive was executed (if)                if (nextLine.push.length && nextLine.pop.length) {···
                    return;
                }
✓ Negative was executed (else)                }···

                markCheck(node);
Branch LogicalExpression
✓ Was returned                if (nextLine.push.length && nextLine.pop.length) {
✓ Was returned                if (nextLine.push.length && nextLine.pop.length) {
                if (nextLine.push.length && nextLine.pop.length) {
                    return;
                }
                markCheck(node);
            });
        }
        var _this = this;
        var moduleBody;
        var indentChar = this._indentChar;
        var indentSize = this._indentSize;
        var indentStack = [0];
Function (anonymous_452)
✓ Was called        var linesToCheck = file.getLines().map(function(line) {···
            return {
                push: [],
                pushAltLine: [],
                pop: [],
                check: false,
                indentation: getIndentationFromLine(line),
                empty: line.match(/^\s*$/)
            };
        });
        var linesToCheck = file.getLines().map(function(line) {
            return {
                push: [],
                pushAltLine: [],
                pop: [],
                check: false,
                indentation: getIndentationFromLine(line),
                empty: line.match(/^\s*$/)
            };
        });
        generateIndentations();
        checkIndentations();
    }
};

disallow-trailing-whitespace.js
/**
 * Requires all lines to end on a non-whitespace character
 *
 * Types: `Boolean` or `String`
 *
 * Values:
 *  - `true`
 *  - `"ignoreEmptyLines"`: (default: `false`) allow whitespace on empty lines
 *
 * JSHint: [`trailing`](http://jshint.com/docs/options/#trailing)
 *
 * #### Example
 *
 * ```js
 * "disallowTrailingWhitespace": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var foo = "blah blah";
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var foo = "blah blah"; //<-- whitespace character here
 * ```
 *
 * ##### Valid for `true`
 *
 * ```js
 * foo = 'bar';
 *
 * foo = 'baz';
 * ```
 *
 * ##### Invalid for `true` but Valid for `ignoreEmptyLines`
 *
 * ```js
 * foo = 'bar';
 * \t
 * foo = 'baz';
 * ```
 */
var assert = require('assert');
Function (anonymous_453)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_454)
✓ Was called    configure: function(options) {···
        assert(
            options === true || options === 'ignoreEmptyLines',
            this.getOptionName() + ' option requires a true value or "ignoreEmptyLines"'
        );
        this._ignoreEmptyLines = options === 'ignoreEmptyLines';
    },
    configure: function(options) {
        assert(
Branch LogicalExpression
✓ Was returned            options === true || options === 'ignoreEmptyLines',
✓ Was returned            options === true || options === 'ignoreEmptyLines',
            options === true || options === 'ignoreEmptyLines',
            this.getOptionName() + ' option requires a true value or "ignoreEmptyLines"'
        );
        this._ignoreEmptyLines = options === 'ignoreEmptyLines';
    },
Function (anonymous_455)
✓ Was called    getOptionName: function() {···
        return 'disallowTrailingWhitespace';
    },
    getOptionName: function() {
        return 'disallowTrailingWhitespace';
    },
Function (anonymous_456)
✓ Was called    check: function(file, errors) {···
        var ignoreEmptyLines = this._ignoreEmptyLines;

        var lines = file.getLines();
        for (var i = 0, l = lines.length; i < l; i++) {
            if (lines[i].match(/\s$/) && !(ignoreEmptyLines && lines[i].match(/^\s*$/))) {
                errors.add('Illegal trailing whitespace', i + 1, lines[i].length);
            }
        }
    }
    check: function(file, errors) {
        var ignoreEmptyLines = this._ignoreEmptyLines;
        var lines = file.getLines();
        for (var i = 0, l = lines.length; i < l; i++) {
Branch IfStatement
✓ Positive was executed (if)            if (lines[i].match(/\s$/) && !(ignoreEmptyLines && lines[i].match(/^\s*$/))) {···
                errors.add('Illegal trailing whitespace', i + 1, lines[i].length);
            }
✓ Negative was executed (else)            }···
        }
Branch LogicalExpression
✓ Was returned            if (lines[i].match(/\s$/) && !(ignoreEmptyLines && lines[i].match(/^\s*$/))) {
✓ Was returned            if (lines[i].match(/\s$/) && !(ignoreEmptyLines && lines[i].match(/^\s*$/))) {
Branch LogicalExpression
✓ Was returned            if (lines[i].match(/\s$/) && !(ignoreEmptyLines && lines[i].match(/^\s*$/))) {
✓ Was returned            if (lines[i].match(/\s$/) && !(ignoreEmptyLines && lines[i].match(/^\s*$/))) {
            if (lines[i].match(/\s$/) && !(ignoreEmptyLines && lines[i].match(/^\s*$/))) {
                errors.add('Illegal trailing whitespace', i + 1, lines[i].length);
            }
        }
    }
};

disallow-mixed-spaces-and-tabs.js
/**
 * Requires lines to not contain both spaces and tabs consecutively,
 * or spaces after tabs only for alignment if "smart"
 *
 * Types: `Boolean` or `String`
 *
 * Values: `true` or `"smart"`
 *
 * JSHint: [`smarttabs`](http://www.jshint.com/docs/options/#smarttabs)
 *
 * #### Example
 *
 * ```js
 * "disallowMixedSpacesAndTabs": true
 * ```
 *
 * ##### Valid example for mode `true`
 *
 * ```js
 * \tvar foo = "blah blah";
 * \s\s\s\svar foo = "blah blah";
 * \t/**
 * \t\s*
 * \t\s*\/ //a single space to align the star in a multi-line comment is allowed
 * ```
 *
 * ##### Invalid example for mode `true`
 *
 * ```js
 * \t\svar foo = "blah blah";
 * \s\tsvar foo = "blah blah";
 * ```
 *
 * ##### Valid example for mode `"smart"`
 *
 * ```js
 * \tvar foo = "blah blah";
 * \t\svar foo = "blah blah";
 * \s\s\s\svar foo = "blah blah";
 * \t/**
 * \t\s*
 * \t\s*\/ //a single space to align the star in a multi-line comment is allowed
 * ```
 *
 * ##### Invalid example for mode `"smart"`
 *
 * ```js
 * \s\tsvar foo = "blah blah";
 * ```
 */
var assert = require('assert');
Function (anonymous_457)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_458)
✓ Was called    configure: function(options) {···
        assert(
            options === true || options === 'smart',
            this.getOptionName() + ' option requires a true value or "smart"'
        );

        this._options = options;
    },
    configure: function(options) {
        assert(
Branch LogicalExpression
✓ Was returned            options === true || options === 'smart',
✓ Was returned            options === true || options === 'smart',
            options === true || options === 'smart',
            this.getOptionName() + ' option requires a true value or "smart"'
        );
        this._options = options;
    },
Function (anonymous_459)
✓ Was called    getOptionName: function() {···
        return 'disallowMixedSpacesAndTabs';
    },
    getOptionName: function() {
        return 'disallowMixedSpacesAndTabs';
    },
Function (anonymous_460)
✓ Was called    check: function(file, errors) {···
        var test = this._options === true ?
            (/ \t|\t [^\*]|\t $/) :
            (/ \t/);

        file.getLinesWithCommentsRemoved().forEach(function(line, i) {
            if (line.match(test)) {
                errors.add('Mixed spaces and tabs found', i + 1, 0);
            }
        });
    }
    check: function(file, errors) {
Branch ConditionalExpression
✓ Positive was returned (? ...)            (/ \t|\t [^\*]|\t $/) :
✓ Negative was returned (: ...)            (/ \t/);
        var test = this._options === true ?
            (/ \t|\t [^\*]|\t $/) :
            (/ \t/);
Function (anonymous_461)
✓ Was called        file.getLinesWithCommentsRemoved().forEach(function(line, i) {···
            if (line.match(test)) {
                errors.add('Mixed spaces and tabs found', i + 1, 0);
            }
        });
        file.getLinesWithCommentsRemoved().forEach(function(line, i) {
Branch IfStatement
✓ Positive was executed (if)            if (line.match(test)) {···
                errors.add('Mixed spaces and tabs found', i + 1, 0);
            }
✓ Negative was executed (else)            }···
        });
            if (line.match(test)) {
                errors.add('Mixed spaces and tabs found', i + 1, 0);
            }
        });
    }
};

require-keywords-on-new-line.js
/**
 * Requires placing keywords on a new line.
 *
 * Type: `Array`
 *
 * Values: Array of quoted keywords
 *
 * #### Example
 *
 * ```js
 * "requireKeywordsOnNewLine": ["else"]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * if (x < 0) {
 *     x++;
 * }
 * else {
 *     x--;
 * }
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * if (x < 0) {
 *     x++;
 * } else {
 *     x--;
 * }
 * ```
 */
var assert = require('assert');
Function (anonymous_462)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_463)
✓ Was called    configure: function(keywords) {···
        assert(Array.isArray(keywords), this.getOptionName() + ' option requires array value');
        this._keywords = keywords;
    },
    configure: function(keywords) {
        assert(Array.isArray(keywords), this.getOptionName() + ' option requires array value');
        this._keywords = keywords;
    },
Function (anonymous_464)
✓ Was called    getOptionName: function() {···
        return 'requireKeywordsOnNewLine';
    },
    getOptionName: function() {
        return 'requireKeywordsOnNewLine';
    },
Function (anonymous_465)
✓ Was called    check: function(file, errors) {···
        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {
            errors.assert.differentLine({
                token: file.getPrevToken(token),
                nextToken: token
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_466)
✓ Was called        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {···
            errors.assert.differentLine({
                token: file.getPrevToken(token),
                nextToken: token
            });
        });
        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {
            errors.assert.differentLine({
                token: file.getPrevToken(token),
                nextToken: token
            });
        });
    }
};

disallow-keywords-on-new-line.js
/**
 * Disallows placing keywords on a new line.
 *
 * Type: `Array`
 *
 * Values: Array of quoted keywords
 *
 * #### Example
 *
 * ```js
 * "disallowKeywordsOnNewLine": ["else"]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * if (x < 0) {
 *     x++;
 * } else {
 *     x--;
 * }
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * if (x < 0) {
 *     x++;
 * }
 * else {
 *     x--;
 * }
 * ```
 */
var assert = require('assert');
Function (anonymous_467)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_468)
✓ Was called    configure: function(keywords) {···
        assert(Array.isArray(keywords), this.getOptionName() + ' option requires array value');
        this._keywords = keywords;
    },
    configure: function(keywords) {
        assert(Array.isArray(keywords), this.getOptionName() + ' option requires array value');
        this._keywords = keywords;
    },
Function (anonymous_469)
✓ Was called    getOptionName: function() {···
        return 'disallowKeywordsOnNewLine';
    },
    getOptionName: function() {
        return 'disallowKeywordsOnNewLine';
    },
Function (anonymous_470)
✓ Was called    check: function(file, errors) {···
        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {
            var prevToken = file.getPrevToken(token);

            // Special case for #905, even though it contradicts rule meaning,
            // it makes more sense that way.
            if (token.value === 'else' && prevToken.value !== '}') {
                return;
            }

            // Special cases for #885, using while as the keyword contradicts rule meaning
            // but it is more efficient and reduces complexity of the code in this rule
            if (token.value === 'while') {
                var nodes = file.getNodesByFirstToken(token);

                if (nodes.length === 0) {
                    // "while" that is part of a do will not return nodes as it is not a start token
                    if (prevToken.value !== '}') {
                        // allow "while" that is part of a "do while" with no braces to succeed
                        return;
                    }
                } else {
                    // it is a "while" statement that is not part of a "do while"
                    // , allow it to succeed even though it contradicts rule meaning
                    return;
                }
            }

            errors.assert.sameLine({
                token: prevToken,
                nextToken: token
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_471)
✓ Was called        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {···
            var prevToken = file.getPrevToken(token);

            // Special case for #905, even though it contradicts rule meaning,
            // it makes more sense that way.
            if (token.value === 'else' && prevToken.value !== '}') {
                return;
            }

            // Special cases for #885, using while as the keyword contradicts rule meaning
            // but it is more efficient and reduces complexity of the code in this rule
            if (token.value === 'while') {
                var nodes = file.getNodesByFirstToken(token);

                if (nodes.length === 0) {
                    // "while" that is part of a do will not return nodes as it is not a start token
                    if (prevToken.value !== '}') {
                        // allow "while" that is part of a "do while" with no braces to succeed
                        return;
                    }
                } else {
                    // it is a "while" statement that is not part of a "do while"
                    // , allow it to succeed even though it contradicts rule meaning
                    return;
                }
            }

            errors.assert.sameLine({
                token: prevToken,
                nextToken: token
            });
        });
        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {
            var prevToken = file.getPrevToken(token);
            // Special case for #905, even though it contradicts rule meaning,
            // it makes more sense that way.
Branch IfStatement
✓ Positive was executed (if)            if (token.value === 'else' && prevToken.value !== '}') {···
                return;
            }
✓ Negative was executed (else)            }···

            // Special cases for #885, using while as the keyword contradicts rule meaning
Branch LogicalExpression
✓ Was returned            if (token.value === 'else' && prevToken.value !== '}') {
✓ Was returned            if (token.value === 'else' && prevToken.value !== '}') {
            if (token.value === 'else' && prevToken.value !== '}') {
                return;
            }
            // Special cases for #885, using while as the keyword contradicts rule meaning
            // but it is more efficient and reduces complexity of the code in this rule
Branch IfStatement
✓ Positive was executed (if)            if (token.value === 'while') {···
                var nodes = file.getNodesByFirstToken(token);

                if (nodes.length === 0) {
                    // "while" that is part of a do will not return nodes as it is not a start token
                    if (prevToken.value !== '}') {
                        // allow "while" that is part of a "do while" with no braces to succeed
                        return;
                    }
                } else {
                    // it is a "while" statement that is not part of a "do while"
                    // , allow it to succeed even though it contradicts rule meaning
                    return;
                }
            }
✓ Negative was executed (else)            }···

            errors.assert.sameLine({
            if (token.value === 'while') {
                var nodes = file.getNodesByFirstToken(token);
Branch IfStatement
✓ Positive was executed (if)                if (nodes.length === 0) {···
                    // "while" that is part of a do will not return nodes as it is not a start token
                    if (prevToken.value !== '}') {
                        // allow "while" that is part of a "do while" with no braces to succeed
                        return;
                    }
                } else {
✓ Negative was executed (else)                } else {···
                    // it is a "while" statement that is not part of a "do while"
                    // , allow it to succeed even though it contradicts rule meaning
                    return;
                }
                if (nodes.length === 0) {
                    // "while" that is part of a do will not return nodes as it is not a start token
Branch IfStatement
✓ Positive was executed (if)                    if (prevToken.value !== '}') {···
                        // allow "while" that is part of a "do while" with no braces to succeed
                        return;
                    }
✓ Negative was executed (else)                    }···
                } else {
                    if (prevToken.value !== '}') {
                        // allow "while" that is part of a "do while" with no braces to succeed
                        return;
                    }
                } else {
                    // it is a "while" statement that is not part of a "do while"
                    // , allow it to succeed even though it contradicts rule meaning
                    return;
                }
            }
            errors.assert.sameLine({
                token: prevToken,
                nextToken: token
            });
        });
    }
};

require-line-feed-at-file-end.js
/**
 * Requires placing line feed at file end.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "requireLineFeedAtFileEnd": true
 * ```
 */
var assert = require('assert');
Function (anonymous_472)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_473)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_474)
✓ Was called    getOptionName: function() {···
        return 'requireLineFeedAtFileEnd';
    },
    getOptionName: function() {
        return 'requireLineFeedAtFileEnd';
    },
Function (anonymous_475)
✓ Was called    check: function(file, errors) {···
        var lastToken = file.getLastToken();
        var prevToken = file.getPrevToken(lastToken, {includeComments: true});
        errors.assert.differentLine({
            token: prevToken,
            nextToken: lastToken,
            message: 'Missing line feed at file end'
        });
    }
    check: function(file, errors) {
        var lastToken = file.getLastToken();
        var prevToken = file.getPrevToken(lastToken, {includeComments: true});
        errors.assert.differentLine({
            token: prevToken,
            nextToken: lastToken,
            message: 'Missing line feed at file end'
        });
    }
};

maximum-line-length.js
/**
 * Requires all lines to be at most the number of characters specified
 *
 * Types: `Integer` or `Object`
 *
 * Values:
 *  - `Integer`: lines should be at most the number of characters specified
 *  - `Object`:
 *     - `value`: (required) lines should be at most the number of characters specified
 *     - `tabSize`: (default: `1`) considered the tab character as number of specified spaces
 *     - `allowComments`: (default: `false`) allows comments to break the rule
 *     - `allowUrlComments`: (default: `false`) allows comments with long urls to break the rule
 *     - `allowRegex`: (default: `false`) allows regular expression literals to break the rule
 *
 * JSHint: [`maxlen`](http://jshint.com/docs/options/#maxlen)
 *
 * #### Example
 *
 * ```js
 * "maximumLineLength": 40
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var aLineOf40Chars = 123456789012345678;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var aLineOf41Chars = 1234567890123456789;
 * ```
 */
var assert = require('assert');
Function (anonymous_476)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_477)
✓ Was called    configure: function(maximumLineLength) {···
        this._tabSize = '';
        this._allowRegex = false;
        this._allowComments = false;
        this._allowUrlComments = false;

        if (typeof maximumLineLength === 'object') {
            assert(
                typeof maximumLineLength.value === 'number',
                this.getOptionName() + ' option requires the "value" property to be defined'
            );

            this._maximumLineLength = maximumLineLength.value;
            var tabSize = maximumLineLength.tabSize || 0;

            while (tabSize--) {
                this._tabSize += ' ';
            }

            this._allowRegex = (maximumLineLength.allowRegex === true);
            this._allowComments = (maximumLineLength.allowComments === true);
            this._allowUrlComments = (maximumLineLength.allowUrlComments === true);
        } else {
            assert(
                typeof maximumLineLength === 'number',
                this.getOptionName() + ' option requires number value or options object'
            );

            this._maximumLineLength = maximumLineLength;
        }
    },
    configure: function(maximumLineLength) {
        this._tabSize = '';
        this._allowRegex = false;
        this._allowComments = false;
        this._allowUrlComments = false;
Branch IfStatement
✓ Positive was executed (if)        if (typeof maximumLineLength === 'object') {···
            assert(
                typeof maximumLineLength.value === 'number',
                this.getOptionName() + ' option requires the "value" property to be defined'
            );

            this._maximumLineLength = maximumLineLength.value;
            var tabSize = maximumLineLength.tabSize || 0;

            while (tabSize--) {
                this._tabSize += ' ';
            }

            this._allowRegex = (maximumLineLength.allowRegex === true);
            this._allowComments = (maximumLineLength.allowComments === true);
            this._allowUrlComments = (maximumLineLength.allowUrlComments === true);
        } else {
✓ Negative was executed (else)        } else {···
            assert(
                typeof maximumLineLength === 'number',
                this.getOptionName() + ' option requires number value or options object'
            );

            this._maximumLineLength = maximumLineLength;
        }
        if (typeof maximumLineLength === 'object') {
            assert(
                typeof maximumLineLength.value === 'number',
                this.getOptionName() + ' option requires the "value" property to be defined'
            );
            this._maximumLineLength = maximumLineLength.value;
Branch LogicalExpression
✓ Was returned            var tabSize = maximumLineLength.tabSize || 0;
✓ Was returned            var tabSize = maximumLineLength.tabSize || 0;
            var tabSize = maximumLineLength.tabSize || 0;
            while (tabSize--) {
                this._tabSize += ' ';
            }
            this._allowRegex = (maximumLineLength.allowRegex === true);
            this._allowComments = (maximumLineLength.allowComments === true);
            this._allowUrlComments = (maximumLineLength.allowUrlComments === true);
        } else {
            assert(
                typeof maximumLineLength === 'number',
                this.getOptionName() + ' option requires number value or options object'
            );
            this._maximumLineLength = maximumLineLength;
        }
    },
Function (anonymous_478)
✓ Was called    getOptionName: function() {···
        return 'maximumLineLength';
    },
    getOptionName: function() {
        return 'maximumLineLength';
    },
Function (anonymous_479)
✓ Was called    check: function(file, errors) {···
        var maximumLineLength = this._maximumLineLength;

        var line;
        var lines = this._allowComments ?
            file.getLinesWithCommentsRemoved() : file.getLines();

        // This check should not be destructive
        lines = lines.slice();

        if (this._allowRegex) {
            file.iterateTokensByType('RegularExpression', function(token) {
                for (var i = token.loc.start.line; i <= token.loc.end.line; i++) {
                    lines[i - 1] = '';
                }
            });
        }

        if (this._allowUrlComments) {
            file.iterateTokensByType(['Line', 'Block'], function(comment) {
                for (var i = comment.loc.start.line; i <= comment.loc.end.line; i++) {
                    lines[i - 1] = lines[i - 1].replace(/(http|https|ftp):\/\/[^\s$]+/, '');
                }
            });
        }

        for (var i = 0, l = lines.length; i < l; i++) {
            line = this._tabSize ? lines[i].replace(/\t/g, this._tabSize) : lines[i];

            if (line.length > maximumLineLength) {
                errors.add(
                    'Line must be at most ' + maximumLineLength + ' characters',
                    i + 1,
                    lines[i].length
                );
            }
        }
    }
    check: function(file, errors) {
        var maximumLineLength = this._maximumLineLength;
        var line;
Branch ConditionalExpression
✓ Positive was returned (? ...)            file.getLinesWithCommentsRemoved() : file.getLines();
✓ Negative was returned (: ...)            file.getLinesWithCommentsRemoved() : file.getLines();
        var lines = this._allowComments ?
            file.getLinesWithCommentsRemoved() : file.getLines();
        // This check should not be destructive
        lines = lines.slice();
Branch IfStatement
✓ Positive was executed (if)        if (this._allowRegex) {···
            file.iterateTokensByType('RegularExpression', function(token) {
                for (var i = token.loc.start.line; i <= token.loc.end.line; i++) {
                    lines[i - 1] = '';
                }
            });
        }
✓ Negative was executed (else)        }···

        if (this._allowUrlComments) {
        if (this._allowRegex) {
Function (anonymous_480)
✓ Was called            file.iterateTokensByType('RegularExpression', function(token) {···
                for (var i = token.loc.start.line; i <= token.loc.end.line; i++) {
                    lines[i - 1] = '';
                }
            });
            file.iterateTokensByType('RegularExpression', function(token) {
                for (var i = token.loc.start.line; i <= token.loc.end.line; i++) {
                    lines[i - 1] = '';
                }
            });
        }
Branch IfStatement
✓ Positive was executed (if)        if (this._allowUrlComments) {···
            file.iterateTokensByType(['Line', 'Block'], function(comment) {
                for (var i = comment.loc.start.line; i <= comment.loc.end.line; i++) {
                    lines[i - 1] = lines[i - 1].replace(/(http|https|ftp):\/\/[^\s$]+/, '');
                }
            });
        }
✓ Negative was executed (else)        }···

        for (var i = 0, l = lines.length; i < l; i++) {
        if (this._allowUrlComments) {
Function (anonymous_481)
✓ Was called            file.iterateTokensByType(['Line', 'Block'], function(comment) {···
                for (var i = comment.loc.start.line; i <= comment.loc.end.line; i++) {
                    lines[i - 1] = lines[i - 1].replace(/(http|https|ftp):\/\/[^\s$]+/, '');
                }
            });
            file.iterateTokensByType(['Line', 'Block'], function(comment) {
                for (var i = comment.loc.start.line; i <= comment.loc.end.line; i++) {
                    lines[i - 1] = lines[i - 1].replace(/(http|https|ftp):\/\/[^\s$]+/, '');
                }
            });
        }
        for (var i = 0, l = lines.length; i < l; i++) {
Branch ConditionalExpression
✓ Positive was returned (? ...)            line = this._tabSize ? lines[i].replace(/\t/g, this._tabSize) : lines[i];
✓ Negative was returned (: ...)            line = this._tabSize ? lines[i].replace(/\t/g, this._tabSize) : lines[i];
            line = this._tabSize ? lines[i].replace(/\t/g, this._tabSize) : lines[i];
Branch IfStatement
✓ Positive was executed (if)            if (line.length > maximumLineLength) {···
                errors.add(
                    'Line must be at most ' + maximumLineLength + ' characters',
                    i + 1,
                    lines[i].length
                );
            }
✓ Negative was executed (else)            }···
        }
            if (line.length > maximumLineLength) {
                errors.add(
                    'Line must be at most ' + maximumLineLength + ' characters',
                    i + 1,
                    lines[i].length
                );
            }
        }
    }
};

require-yoda-conditions.js
/**
 * Requires the variable to be the right hand operator when doing a boolean comparison
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "requireYodaConditions": true
 * ```
 *
 * ##### Valid
 * ```js
 * if (1 == a) {
 *     return
 * }
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * if (a == 1) {
 *     return
 * }
 * ```
 */
var assert = require('assert');
Function (anonymous_482)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_483)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
        this._operatorIndex = {
            '==': true,
            '===': true,
            '!=': true,
            '!==': true,
            '>': true,
            '<': true,
            '>=': true,
            '<=': true
        };
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
        this._operatorIndex = {
            '==': true,
            '===': true,
            '!=': true,
            '!==': true,
            '>': true,
            '<': true,
            '>=': true,
            '<=': true
        };
    },
Function (anonymous_484)
✓ Was called    getOptionName: function() {···
        return 'requireYodaConditions';
    },
    getOptionName: function() {
        return 'requireYodaConditions';
    },
Function (anonymous_485)
✓ Was called    check: function(file, errors) {···
        var operators = this._operatorIndex;
        file.iterateNodesByType('BinaryExpression', function(node) {
            if (operators[node.operator]) {
                if (node.right.type === 'Literal' ||
                    (node.right.type === 'Identifier' && node.right.name === 'undefined')
                ) {
                    errors.add('Not yoda condition', node.left.loc.start);
                }
            }
        });
    }
    check: function(file, errors) {
        var operators = this._operatorIndex;
Function (anonymous_486)
✓ Was called        file.iterateNodesByType('BinaryExpression', function(node) {···
            if (operators[node.operator]) {
                if (node.right.type === 'Literal' ||
                    (node.right.type === 'Identifier' && node.right.name === 'undefined')
                ) {
                    errors.add('Not yoda condition', node.left.loc.start);
                }
            }
        });
        file.iterateNodesByType('BinaryExpression', function(node) {
Branch IfStatement
✓ Positive was executed (if)            if (operators[node.operator]) {···
                if (node.right.type === 'Literal' ||
                    (node.right.type === 'Identifier' && node.right.name === 'undefined')
                ) {
                    errors.add('Not yoda condition', node.left.loc.start);
                }
            }
✓ Negative was executed (else)            }···
        });
            if (operators[node.operator]) {
Branch IfStatement
✓ Positive was executed (if)                ) {···
                    errors.add('Not yoda condition', node.left.loc.start);
                }
✓ Negative was executed (else)                }···
            }
Branch LogicalExpression
✓ Was returned                    (node.right.type === 'Identifier' && node.right.name === 'undefined')
✓ Was returned                if (node.right.type === 'Literal' ||
                if (node.right.type === 'Literal' ||
Branch LogicalExpression
✓ Was returned                    (node.right.type === 'Identifier' && node.right.name === 'undefined')
✓ Was returned                    (node.right.type === 'Identifier' && node.right.name === 'undefined')
                    (node.right.type === 'Identifier' && node.right.name === 'undefined')
                ) {
                    errors.add('Not yoda condition', node.left.loc.start);
                }
            }
        });
    }
};

disallow-yoda-conditions.js
/**
 * Requires the variable to be the left hand operator when doing a boolean comparison
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowYodaConditions": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * if (a == 1) {
 *     return
 * }
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * if (1 == a) {
 *     return
 * }
 * ```
 */
var assert = require('assert');
Function (anonymous_487)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_488)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
        this._operatorIndex = {
            '==': true,
            '===': true,
            '!=': true,
            '!==': true,
            '>': true,
            '<': true,
            '>=': true,
            '<=': true
        };
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
        this._operatorIndex = {
            '==': true,
            '===': true,
            '!=': true,
            '!==': true,
            '>': true,
            '<': true,
            '>=': true,
            '<=': true
        };
    },
Function (anonymous_489)
✓ Was called    getOptionName: function() {···
        return 'disallowYodaConditions';
    },
    getOptionName: function() {
        return 'disallowYodaConditions';
    },
Function (anonymous_490)
✓ Was called    check: function(file, errors) {···
        var operators = this._operatorIndex;
        file.iterateNodesByType('BinaryExpression', function(node) {
            if (operators[node.operator]) {
                if (node.left.type === 'Literal' ||
                    (node.left.type === 'Identifier' && node.left.name === 'undefined')
                ) {
                    errors.add('Yoda condition', node.left.loc.start);
                }
            }
        });
    }
    check: function(file, errors) {
        var operators = this._operatorIndex;
Function (anonymous_491)
✓ Was called        file.iterateNodesByType('BinaryExpression', function(node) {···
            if (operators[node.operator]) {
                if (node.left.type === 'Literal' ||
                    (node.left.type === 'Identifier' && node.left.name === 'undefined')
                ) {
                    errors.add('Yoda condition', node.left.loc.start);
                }
            }
        });
        file.iterateNodesByType('BinaryExpression', function(node) {
Branch IfStatement
✓ Positive was executed (if)            if (operators[node.operator]) {···
                if (node.left.type === 'Literal' ||
                    (node.left.type === 'Identifier' && node.left.name === 'undefined')
                ) {
                    errors.add('Yoda condition', node.left.loc.start);
                }
            }
✓ Negative was executed (else)            }···
        });
            if (operators[node.operator]) {
Branch IfStatement
✓ Positive was executed (if)                ) {···
                    errors.add('Yoda condition', node.left.loc.start);
                }
✓ Negative was executed (else)                }···
            }
Branch LogicalExpression
✓ Was returned                    (node.left.type === 'Identifier' && node.left.name === 'undefined')
✓ Was returned                if (node.left.type === 'Literal' ||
                if (node.left.type === 'Literal' ||
Branch LogicalExpression
✓ Was returned                    (node.left.type === 'Identifier' && node.left.name === 'undefined')
✓ Was returned                    (node.left.type === 'Identifier' && node.left.name === 'undefined')
                    (node.left.type === 'Identifier' && node.left.name === 'undefined')
                ) {
                    errors.add('Yoda condition', node.left.loc.start);
                }
            }
        });
    }
};

require-spaces-inside-brackets.js
/**
 * Requires space after opening square bracket and before closing.
 *
 * Types: `Boolean` or `Object`
 *
 * Values: `true` for strict mode, or `"allExcept": [ "[", "]"]`
 * ignores closing brackets in a row.
 *
 * #### Example
 *
 * ```js
 * "requireSpacesInsideBrackets": true
 *
 * // or
 *
 * "requireSpacesInsideBrackets": {
 *     "allExcept": [ "[", "]", "{", "}" ]
 * }
 * ```
 *
 * ##### Valid for mode `true`
 *
 * ```js
 * var x = [ 1 ];
 * ```
 *
 * ##### Valid for mode `{ allExcept": [ "[", "]", "{", "}" ] }`
 *
 * ```js
 * var x = [[ 1 ], [ 2 ]];
 * var x = [{ a: 1 }, { b: 2}];
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = [1];
 * ```
 */
var assert = require('assert');
Function (anonymous_492)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_493)
✓ Was called    configure: function(value) {···
        var isObject = typeof value === 'object';

        var error = this.getOptionName() + ' rule requires string value true or object';

        if (isObject) {
            assert('allExcept' in value, error);
        } else {
            assert(value === true, error);
        }

        this._exceptions = {};

        if (isObject) {
            (value.allExcept || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);
        }
    },
    configure: function(value) {
        var isObject = typeof value === 'object';
        var error = this.getOptionName() + ' rule requires string value true or object';
Branch IfStatement
✓ Positive was executed (if)        if (isObject) {···
            assert('allExcept' in value, error);
        } else {
✓ Negative was executed (else)        } else {···
            assert(value === true, error);
        }
        if (isObject) {
            assert('allExcept' in value, error);
        } else {
            assert(value === true, error);
        }
        this._exceptions = {};
Branch IfStatement
✓ Positive was executed (if)        if (isObject) {···
            (value.allExcept || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);
        }
✓ Negative was executed (else)        }···
    },
        if (isObject) {
Function (anonymous_494)
✓ Was called            (value.allExcept || []).forEach(function(value) {···
                this._exceptions[value] = true;
            }, this);
Branch LogicalExpression
✗ Was not returned            (value.allExcept || []).forEach(function(value) {
✓ Was returned            (value.allExcept || []).forEach(function(value) {
            (value.allExcept || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);
        }
    },
Function (anonymous_495)
✓ Was called    getOptionName: function() {···
        return 'requireSpacesInsideBrackets';
    },
    getOptionName: function() {
        return 'requireSpacesInsideBrackets';
    },
Function (anonymous_496)
✓ Was called    check: function(file, errors) {···
        var exceptions = this._exceptions;

        file.iterateTokenByValue('[', function(token) {
            var nextToken = file.getNextToken(token);
            var value = nextToken.value;

            if (value in exceptions) {
                return;
            }

            // Skip for empty array brackets
            if (value === ']') {
                return;
            }

            errors.assert.spacesBetween({
                token: token,
                nextToken: nextToken,
                exactly: 1,
                message: 'One space required after opening bracket'
            });
        });

        file.iterateTokenByValue(']', function(token) {
            var prevToken = file.getPrevToken(token);
            var value = prevToken.value;

            if (value in exceptions) {
                return;
            }

            // Skip for empty array brackets
            if (value === '[') {
                return;
            }

            errors.assert.spacesBetween({
                token: prevToken,
                nextToken: token,
                exactly: 1,
                message: 'One space required before closing bracket'
            });
        });
    }
    check: function(file, errors) {
        var exceptions = this._exceptions;
Function (anonymous_497)
✓ Was called        file.iterateTokenByValue('[', function(token) {···
            var nextToken = file.getNextToken(token);
            var value = nextToken.value;

            if (value in exceptions) {
                return;
            }

            // Skip for empty array brackets
            if (value === ']') {
                return;
            }

            errors.assert.spacesBetween({
                token: token,
                nextToken: nextToken,
                exactly: 1,
                message: 'One space required after opening bracket'
            });
        });
        file.iterateTokenByValue('[', function(token) {
            var nextToken = file.getNextToken(token);
            var value = nextToken.value;
Branch IfStatement
✓ Positive was executed (if)            if (value in exceptions) {···
                return;
            }
✓ Negative was executed (else)            }···

            // Skip for empty array brackets
            if (value in exceptions) {
                return;
            }
            // Skip for empty array brackets
Branch IfStatement
✓ Positive was executed (if)            if (value === ']') {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.assert.spacesBetween({
            if (value === ']') {
                return;
            }
            errors.assert.spacesBetween({
                token: token,
                nextToken: nextToken,
                exactly: 1,
                message: 'One space required after opening bracket'
            });
        });
Function (anonymous_498)
✓ Was called        file.iterateTokenByValue(']', function(token) {···
            var prevToken = file.getPrevToken(token);
            var value = prevToken.value;

            if (value in exceptions) {
                return;
            }

            // Skip for empty array brackets
            if (value === '[') {
                return;
            }

            errors.assert.spacesBetween({
                token: prevToken,
                nextToken: token,
                exactly: 1,
                message: 'One space required before closing bracket'
            });
        });
        file.iterateTokenByValue(']', function(token) {
            var prevToken = file.getPrevToken(token);
            var value = prevToken.value;
Branch IfStatement
✓ Positive was executed (if)            if (value in exceptions) {···
                return;
            }
✓ Negative was executed (else)            }···

            // Skip for empty array brackets
            if (value in exceptions) {
                return;
            }
            // Skip for empty array brackets
Branch IfStatement
✓ Positive was executed (if)            if (value === '[') {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.assert.spacesBetween({
            if (value === '[') {
                return;
            }
            errors.assert.spacesBetween({
                token: prevToken,
                nextToken: token,
                exactly: 1,
                message: 'One space required before closing bracket'
            });
        });
    }
};

require-spaces-inside-object-brackets.js
/**
 * Requires space after opening object curly brace and before closing.
 *
 * Types: `Object` or `String`
 *
 * Values: `"all"` for strict mode, `"allButNested"` (*deprecated* use `"allExcept": ['}']`)
 * ignores closing brackets in a row.
 *
 * #### Example
 *
 * ```js
 * "requireSpacesInsideObjectBrackets": {
 *     "allExcept": [ "}", ")" ]
 * }
 *
 * // or
 * "requireSpacesInsideObjectBrackets": true | "all" | "allButNested"
 * ```
 *
 * ##### Valid for mode `"all"`
 *
 * ```js
 * var x = { a: { b: 1 } };
 * ```
 *
 * ##### Valid for mode `"allButNested"`
 *
 * ```js
 * var x = { a: { b: 1 }};
 * ```
 *
 * ##### Valid for mode `"allExcept": [ "}", ")" ]`
 *
 * ```js
 * var x = { a: (b ? 1 : 2)};
 * var x = { a: { b: 1 }};
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = {a: 1};
 * ```
 */
var assert = require('assert');
Function (anonymous_499)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_500)
✓ Was called    configure: function(value) {···
        var mode;
        var modes = {
            'all': true,
            'allButNested': true
        };
        var isObject = typeof value === 'object';

        var error = this.getOptionName() + ' rule' +
        ' requires string value \'all\' or \'allButNested\' or object';

        if (typeof value === 'string') {
            assert(modes[value], error);

        } else if (isObject) {
            assert('allExcept' in value, error);
        } else {
            assert(false, error);
        }

        this._exceptions = {};

        if (isObject) {
            (value.allExcept || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);

        } else {
            mode = value;
        }

        if (mode === 'allButNested') {
            this._exceptions['}'] = true;
        }
    },
    configure: function(value) {
        var mode;
        var modes = {
            'all': true,
            'allButNested': true
        };
        var isObject = typeof value === 'object';
        var error = this.getOptionName() + ' rule' +
        ' requires string value \'all\' or \'allButNested\' or object';
Branch IfStatement
✓ Positive was executed (if)        if (typeof value === 'string') {···
            assert(modes[value], error);

        } else if (isObject) {
✓ Negative was executed (else)        } else if (isObject) {···
            assert('allExcept' in value, error);
        } else {
            assert(false, error);
        }
        if (typeof value === 'string') {
            assert(modes[value], error);
Branch IfStatement
✓ Positive was executed (if)        } else if (isObject) {···
            assert('allExcept' in value, error);
        } else {
✗ Negative was not executed (else)        } else {···
            assert(false, error);
        }
        } else if (isObject) {
            assert('allExcept' in value, error);
        } else {
            assert(false, error);
        }
        this._exceptions = {};
Branch IfStatement
✓ Positive was executed (if)        if (isObject) {···
            (value.allExcept || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);

        } else {
✓ Negative was executed (else)        } else {···
            mode = value;
        }
        if (isObject) {
Function (anonymous_501)
✓ Was called            (value.allExcept || []).forEach(function(value) {···
                this._exceptions[value] = true;
            }, this);
Branch LogicalExpression
✗ Was not returned            (value.allExcept || []).forEach(function(value) {
✓ Was returned            (value.allExcept || []).forEach(function(value) {
            (value.allExcept || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);
        } else {
            mode = value;
        }
Branch IfStatement
✓ Positive was executed (if)        if (mode === 'allButNested') {···
            this._exceptions['}'] = true;
        }
✓ Negative was executed (else)        }···
    },
        if (mode === 'allButNested') {
            this._exceptions['}'] = true;
        }
    },
Function (anonymous_502)
✓ Was called    getOptionName: function() {···
        return 'requireSpacesInsideObjectBrackets';
    },
    getOptionName: function() {
        return 'requireSpacesInsideObjectBrackets';
    },
Function (anonymous_503)
✓ Was called    check: function(file, errors) {···
        var exceptions = this._exceptions;

        file.iterateNodesByType('ObjectExpression', function(node) {
            var openingBracket = file.getFirstNodeToken(node);
            var nextToken = file.getNextToken(openingBracket);

            // Don't check empty object
            if (nextToken.value === '}') {
                return;
            }

            errors.assert.spacesBetween({
                token: openingBracket,
                nextToken: nextToken,
                exactly: 1,
                message: 'One space required after opening curly brace'
            });

            var closingBracket = file.getLastNodeToken(node);
            var prevToken = file.getPrevToken(closingBracket);

            if (prevToken.value in exceptions) {
                return;
            }

            errors.assert.spacesBetween({
                token: prevToken,
                nextToken: closingBracket,
                exactly: 1,
                message: 'One space required before closing curly brace'
            });
        });
    }
    check: function(file, errors) {
        var exceptions = this._exceptions;
Function (anonymous_504)
✓ Was called        file.iterateNodesByType('ObjectExpression', function(node) {···
            var openingBracket = file.getFirstNodeToken(node);
            var nextToken = file.getNextToken(openingBracket);

            // Don't check empty object
            if (nextToken.value === '}') {
                return;
            }

            errors.assert.spacesBetween({
                token: openingBracket,
                nextToken: nextToken,
                exactly: 1,
                message: 'One space required after opening curly brace'
            });

            var closingBracket = file.getLastNodeToken(node);
            var prevToken = file.getPrevToken(closingBracket);

            if (prevToken.value in exceptions) {
                return;
            }

            errors.assert.spacesBetween({
                token: prevToken,
                nextToken: closingBracket,
                exactly: 1,
                message: 'One space required before closing curly brace'
            });
        });
        file.iterateNodesByType('ObjectExpression', function(node) {
            var openingBracket = file.getFirstNodeToken(node);
            var nextToken = file.getNextToken(openingBracket);
            // Don't check empty object
Branch IfStatement
✓ Positive was executed (if)            if (nextToken.value === '}') {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.assert.spacesBetween({
            if (nextToken.value === '}') {
                return;
            }
            errors.assert.spacesBetween({
                token: openingBracket,
                nextToken: nextToken,
                exactly: 1,
                message: 'One space required after opening curly brace'
            });
            var closingBracket = file.getLastNodeToken(node);
            var prevToken = file.getPrevToken(closingBracket);
Branch IfStatement
✓ Positive was executed (if)            if (prevToken.value in exceptions) {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.assert.spacesBetween({
            if (prevToken.value in exceptions) {
                return;
            }
            errors.assert.spacesBetween({
                token: prevToken,
                nextToken: closingBracket,
                exactly: 1,
                message: 'One space required before closing curly brace'
            });
        });
    }
};

require-spaces-inside-array-brackets.js
/**
 * Requires space after opening array square bracket and before closing.
 *
 * Types: `String` or `Object`
 *
 * Values: `"all"` for strict mode, `"allButNested"` (*deprecated* use `"allExcept": [ "[", "]"]`)
 * ignores closing brackets in a row.
 *
 * #### Example
 *
 * ```js
 * "requireSpacesInsideArrayBrackets": "all"
 *
 * // or
 *
 * "requireSpacesInsideArrayBrackets": {
 *     "allExcept": [ "[", "]", "{", "}" ]
 * }
 * ```
 *
 * ##### Valid for mode `"all"`
 *
 * ```js
 * var x = [ 1 ];
 * ```
 *
 * ##### Valid for mode `"allButNested"`
 *
 * ```js
 * var x = [[ 1 ], [ 2 ]];
 * ```
 *
 * ##### Valid for mode `"allExcept"`
 *
 * ```js
 * var x = [[ 1 ], [ 2 ]];
 * var x = [{ a: 1 }, { b: 2}];
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = [1];
 * ```
 */
var assert = require('assert');
Function (anonymous_505)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_506)
✓ Was called    configure: function(value) {···
        var mode;
        var modes = {
            'all': true,
            'allButNested': true
        };
        var isObject = typeof value === 'object';

        var error = this.getOptionName() + ' rule' +
        ' requires string value "all" or "allButNested" or object';

        if (typeof value === 'string') {
            assert(modes[value], error);

        } else if (isObject) {
            assert('allExcept' in value, error);
        } else {
            assert(false, error);
        }

        this._exceptions = {};

        if (isObject) {
            (value.allExcept || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);

        } else {
            mode = value;
        }

        if (mode === 'allButNested') {
            this._exceptions['['] = this._exceptions[']'] = true;
        }
    },
    configure: function(value) {
        var mode;
        var modes = {
            'all': true,
            'allButNested': true
        };
        var isObject = typeof value === 'object';
        var error = this.getOptionName() + ' rule' +
        ' requires string value "all" or "allButNested" or object';
Branch IfStatement
✓ Positive was executed (if)        if (typeof value === 'string') {···
            assert(modes[value], error);

        } else if (isObject) {
✓ Negative was executed (else)        } else if (isObject) {···
            assert('allExcept' in value, error);
        } else {
            assert(false, error);
        }
        if (typeof value === 'string') {
            assert(modes[value], error);
Branch IfStatement
✓ Positive was executed (if)        } else if (isObject) {···
            assert('allExcept' in value, error);
        } else {
✗ Negative was not executed (else)        } else {···
            assert(false, error);
        }
        } else if (isObject) {
            assert('allExcept' in value, error);
        } else {
            assert(false, error);
        }
        this._exceptions = {};
Branch IfStatement
✓ Positive was executed (if)        if (isObject) {···
            (value.allExcept || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);

        } else {
✓ Negative was executed (else)        } else {···
            mode = value;
        }
        if (isObject) {
Function (anonymous_507)
✓ Was called            (value.allExcept || []).forEach(function(value) {···
                this._exceptions[value] = true;
            }, this);
Branch LogicalExpression
✗ Was not returned            (value.allExcept || []).forEach(function(value) {
✓ Was returned            (value.allExcept || []).forEach(function(value) {
            (value.allExcept || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);
        } else {
            mode = value;
        }
Branch IfStatement
✓ Positive was executed (if)        if (mode === 'allButNested') {···
            this._exceptions['['] = this._exceptions[']'] = true;
        }
✓ Negative was executed (else)        }···
    },
        if (mode === 'allButNested') {
            this._exceptions['['] = this._exceptions[']'] = true;
        }
    },
Function (anonymous_508)
✓ Was called    getOptionName: function() {···
        return 'requireSpacesInsideArrayBrackets';
    },
    getOptionName: function() {
        return 'requireSpacesInsideArrayBrackets';
    },
Function (anonymous_509)
✓ Was called    check: function(file, errors) {···
        var exceptions = this._exceptions;

        file.iterateNodesByType('ArrayExpression', function(node) {
            var openBracket = file.getFirstNodeToken(node);
            var afterOpen = file.getNextToken(openBracket, {includeComments: true});
            var closeBracket = file.getLastNodeToken(node);
            var beforeClose = file.getPrevToken(closeBracket, {includeComments: true});

            // Skip for empty array brackets
            if (afterOpen.value === ']') {
                return;
            }

            if (!(afterOpen.value in exceptions)) {
                errors.assert.spacesBetween({
                    token: openBracket,
                    nextToken: afterOpen,
                    exactly: 1,
                    message: 'One space required after opening bracket'
                });
            }

            if (!(beforeClose.value in exceptions)) {
                errors.assert.spacesBetween({
                    token: beforeClose,
                    nextToken: closeBracket,
                    exactly: 1,
                    message: 'One space required before closing bracket'
                });
            }
        });
    }
    check: function(file, errors) {
        var exceptions = this._exceptions;
Function (anonymous_510)
✓ Was called        file.iterateNodesByType('ArrayExpression', function(node) {···
            var openBracket = file.getFirstNodeToken(node);
            var afterOpen = file.getNextToken(openBracket, {includeComments: true});
            var closeBracket = file.getLastNodeToken(node);
            var beforeClose = file.getPrevToken(closeBracket, {includeComments: true});

            // Skip for empty array brackets
            if (afterOpen.value === ']') {
                return;
            }

            if (!(afterOpen.value in exceptions)) {
                errors.assert.spacesBetween({
                    token: openBracket,
                    nextToken: afterOpen,
                    exactly: 1,
                    message: 'One space required after opening bracket'
                });
            }

            if (!(beforeClose.value in exceptions)) {
                errors.assert.spacesBetween({
                    token: beforeClose,
                    nextToken: closeBracket,
                    exactly: 1,
                    message: 'One space required before closing bracket'
                });
            }
        });
        file.iterateNodesByType('ArrayExpression', function(node) {
            var openBracket = file.getFirstNodeToken(node);
            var afterOpen = file.getNextToken(openBracket, {includeComments: true});
            var closeBracket = file.getLastNodeToken(node);
            var beforeClose = file.getPrevToken(closeBracket, {includeComments: true});
            // Skip for empty array brackets
Branch IfStatement
✓ Positive was executed (if)            if (afterOpen.value === ']') {···
                return;
            }
✓ Negative was executed (else)            }···

            if (!(afterOpen.value in exceptions)) {
            if (afterOpen.value === ']') {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (!(afterOpen.value in exceptions)) {···
                errors.assert.spacesBetween({
                    token: openBracket,
                    nextToken: afterOpen,
                    exactly: 1,
                    message: 'One space required after opening bracket'
                });
            }
✓ Negative was executed (else)            }···

            if (!(beforeClose.value in exceptions)) {
            if (!(afterOpen.value in exceptions)) {
                errors.assert.spacesBetween({
                    token: openBracket,
                    nextToken: afterOpen,
                    exactly: 1,
                    message: 'One space required after opening bracket'
                });
            }
Branch IfStatement
✓ Positive was executed (if)            if (!(beforeClose.value in exceptions)) {···
                errors.assert.spacesBetween({
                    token: beforeClose,
                    nextToken: closeBracket,
                    exactly: 1,
                    message: 'One space required before closing bracket'
                });
            }
✓ Negative was executed (else)            }···
        });
            if (!(beforeClose.value in exceptions)) {
                errors.assert.spacesBetween({
                    token: beforeClose,
                    nextToken: closeBracket,
                    exactly: 1,
                    message: 'One space required before closing bracket'
                });
            }
        });
    }
};

require-spaces-inside-parentheses.js
/**
 * Requires space after opening round bracket and before closing.
 *
 * Types: `Object` or `String`
 *
 * Values: `"all"` for strict mode, `"allButNested"`
 * (*deprecated* use `"except": ['(', ')']`) ignores nested brackets in a row, you could also specify token exceptions.
 *
 * #### Example
 *
 * ```js
 * "requireSpacesInsideParentheses": {
 *     "all": true,
 *     "except": [ "{", "}" ]
 * }
 * ```
 *
 * ##### Valid for mode `"all"`
 *
 * ```js
 * var x = Math.pow( ( 1 + 2 ), ( 3 + 4 ) );
 * ```
 *
 * ##### Valid for mode `"allButNested"`
 *
 * ```js
 * var x = Math.pow(( 1 + 2 ), ( 3 + 4 ));
 * ```
 *
 * ##### Valid for mode `"all"` with `except`
 *
 * ```js
 * var x = Math.pow( foo({ test: 1 }) );
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = Math.pow(1 + 2, 3 + 4);
 * ```
 */
var assert = require('assert');
Function (anonymous_511)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_512)
✓ Was called    configure: function(value) {···
        var mode;
        var modes = {
            'all': true,
            'allButNested': true
        };
        var isObject = typeof value === 'object';

        var error = this.getOptionName() + ' rule' +
        ' requires string value \'all\' or \'allButNested\' or object';

        if (typeof value === 'string') {
            assert(modes[value], error);

        } else if (isObject) {
            assert(
                'all' in value || 'allButNested' in value,
                error
            );
        } else {
            assert(false, error);
        }

        this._exceptions = {};

        if (isObject) {
            mode = 'all' in value ? 'all' : 'allButNested';

            (value.except || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);

        } else {
            mode = value;
        }

        if (mode === 'allButNested') {
            this._exceptions[')'] = this._exceptions['('] = true;
        }
    },
    configure: function(value) {
        var mode;
        var modes = {
            'all': true,
            'allButNested': true
        };
        var isObject = typeof value === 'object';
        var error = this.getOptionName() + ' rule' +
        ' requires string value \'all\' or \'allButNested\' or object';
Branch IfStatement
✓ Positive was executed (if)        if (typeof value === 'string') {···
            assert(modes[value], error);

        } else if (isObject) {
✓ Negative was executed (else)        } else if (isObject) {···
            assert(
                'all' in value || 'allButNested' in value,
                error
            );
        } else {
            assert(false, error);
        }
        if (typeof value === 'string') {
            assert(modes[value], error);
Branch IfStatement
✓ Positive was executed (if)        } else if (isObject) {···
            assert(
                'all' in value || 'allButNested' in value,
                error
            );
        } else {
✓ Negative was executed (else)        } else {···
            assert(false, error);
        }
        } else if (isObject) {
            assert(
Branch LogicalExpression
✗ Was not returned                'all' in value || 'allButNested' in value,
✓ Was returned                'all' in value || 'allButNested' in value,
                'all' in value || 'allButNested' in value,
                error
            );
        } else {
            assert(false, error);
        }
        this._exceptions = {};
Branch IfStatement
✓ Positive was executed (if)        if (isObject) {···
            mode = 'all' in value ? 'all' : 'allButNested';

            (value.except || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);

        } else {
✓ Negative was executed (else)        } else {···
            mode = value;
        }
        if (isObject) {
Branch ConditionalExpression
✓ Positive was returned (? ...)            mode = 'all' in value ? 'all' : 'allButNested';
✗ Negative was not returned (: ...)            mode = 'all' in value ? 'all' : 'allButNested';
            mode = 'all' in value ? 'all' : 'allButNested';
Function (anonymous_513)
✓ Was called            (value.except || []).forEach(function(value) {···
                this._exceptions[value] = true;
            }, this);
Branch LogicalExpression
✗ Was not returned            (value.except || []).forEach(function(value) {
✓ Was returned            (value.except || []).forEach(function(value) {
            (value.except || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);
        } else {
            mode = value;
        }
Branch IfStatement
✓ Positive was executed (if)        if (mode === 'allButNested') {···
            this._exceptions[')'] = this._exceptions['('] = true;
        }
✓ Negative was executed (else)        }···
    },
        if (mode === 'allButNested') {
            this._exceptions[')'] = this._exceptions['('] = true;
        }
    },
Function (anonymous_514)
✓ Was called    getOptionName: function() {···
        return 'requireSpacesInsideParentheses';
    },
    getOptionName: function() {
        return 'requireSpacesInsideParentheses';
    },
Function (anonymous_515)
✓ Was called    check: function(file, errors) {···
        var exceptions = this._exceptions;

        file.iterateTokenByValue('(', function(token) {
            var nextToken = file.getNextToken(token, {includeComments: true});
            var value = nextToken.value;

            if (value in exceptions) {
                return;
            }

            // Skip for empty parentheses
            if (value === ')') {
                return;
            }

            errors.assert.whitespaceBetween({
                token: token,
                nextToken: nextToken,
                message: 'Missing space after opening round bracket'
            });
        });

        file.iterateTokenByValue(')', function(token) {
            var prevToken = file.getPrevToken(token, {includeComments: true});
            var value = prevToken.value;

            if (value in exceptions) {

                // Special case - foo( object[i] )
                if (!(
                    value === ']' &&
                    file.getNodeByRange(token.range[0] - 1).type === 'MemberExpression'
                )) {
                    return;
                }
            }

            // Skip for empty parentheses
            if (value === '(') {
                return;
            }

            errors.assert.whitespaceBetween({
                token: prevToken,
                nextToken: token,
                message: 'Missing space before closing round bracket'
            });
        });
    }
    check: function(file, errors) {
        var exceptions = this._exceptions;
Function (anonymous_516)
✓ Was called        file.iterateTokenByValue('(', function(token) {···
            var nextToken = file.getNextToken(token, {includeComments: true});
            var value = nextToken.value;

            if (value in exceptions) {
                return;
            }

            // Skip for empty parentheses
            if (value === ')') {
                return;
            }

            errors.assert.whitespaceBetween({
                token: token,
                nextToken: nextToken,
                message: 'Missing space after opening round bracket'
            });
        });
        file.iterateTokenByValue('(', function(token) {
            var nextToken = file.getNextToken(token, {includeComments: true});
            var value = nextToken.value;
Branch IfStatement
✓ Positive was executed (if)            if (value in exceptions) {···
                return;
            }
✓ Negative was executed (else)            }···

            // Skip for empty parentheses
            if (value in exceptions) {
                return;
            }
            // Skip for empty parentheses
Branch IfStatement
✓ Positive was executed (if)            if (value === ')') {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.assert.whitespaceBetween({
            if (value === ')') {
                return;
            }
            errors.assert.whitespaceBetween({
                token: token,
                nextToken: nextToken,
                message: 'Missing space after opening round bracket'
            });
        });
Function (anonymous_517)
✓ Was called        file.iterateTokenByValue(')', function(token) {···
            var prevToken = file.getPrevToken(token, {includeComments: true});
            var value = prevToken.value;

            if (value in exceptions) {

                // Special case - foo( object[i] )
                if (!(
                    value === ']' &&
                    file.getNodeByRange(token.range[0] - 1).type === 'MemberExpression'
                )) {
                    return;
                }
            }

            // Skip for empty parentheses
            if (value === '(') {
                return;
            }

            errors.assert.whitespaceBetween({
                token: prevToken,
                nextToken: token,
                message: 'Missing space before closing round bracket'
            });
        });
        file.iterateTokenByValue(')', function(token) {
            var prevToken = file.getPrevToken(token, {includeComments: true});
            var value = prevToken.value;
Branch IfStatement
✓ Positive was executed (if)            if (value in exceptions) {···

                // Special case - foo( object[i] )
                if (!(
                    value === ']' &&
                    file.getNodeByRange(token.range[0] - 1).type === 'MemberExpression'
                )) {
                    return;
                }
            }
✓ Negative was executed (else)            }···

            // Skip for empty parentheses
            if (value in exceptions) {
                // Special case - foo( object[i] )
Branch IfStatement
✓ Positive was executed (if)                )) {···
                    return;
                }
✓ Negative was executed (else)                }···
            }
                if (!(
Branch LogicalExpression
✓ Was returned                    file.getNodeByRange(token.range[0] - 1).type === 'MemberExpression'
✓ Was returned                    value === ']' &&
                    value === ']' &&
                    file.getNodeByRange(token.range[0] - 1).type === 'MemberExpression'
                )) {
                    return;
                }
            }
            // Skip for empty parentheses
Branch IfStatement
✓ Positive was executed (if)            if (value === '(') {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.assert.whitespaceBetween({
            if (value === '(') {
                return;
            }
            errors.assert.whitespaceBetween({
                token: prevToken,
                nextToken: token,
                message: 'Missing space before closing round bracket'
            });
        });
    }
};

disallow-spaces-inside-brackets.js
/**
 * Disallows space after opening square bracket and before closing.
 *
 * Types: `Boolean` or `Object`
 *
 * Values: `true` for strict mode, or `"allExcept": [ "[", "]" ]`
 * ignores closing brackets in a row.
 *
 * #### Example
 *
 * ```js
 * "disallowSpacesInsideBrackets": true
 *
 * // or
 *
 * "disallowSpacesInsideBrackets": {
 *     "allExcept": [ "[", "]", "{", "}" ]
 * }
 * ```
 *
 * ##### Valid for mode `true`
 *
 * ```js
 * var x = [[1]];
 * ```
 *
 * ##### Valid for mode `{ allExcept": [ "[", "]", "{", "}" ] }`
 *
 * ```js
 * var x = [ [1] ];
 * var x = [ { a: 1 } ];
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = [ [ 1 ] ];
 * ```
 */
var assert = require('assert');
Function (anonymous_518)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_519)
✓ Was called    configure: function(value) {···
        var isObject = typeof value === 'object';

        var error = this.getOptionName() + ' rule requires string value true or object';

        if (isObject) {
            assert('allExcept' in value, error);
        } else {
            assert(value === true, error);
        }

        this._exceptions = {};

        if (isObject) {
            (value.allExcept || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);
        }
    },
    configure: function(value) {
        var isObject = typeof value === 'object';
        var error = this.getOptionName() + ' rule requires string value true or object';
Branch IfStatement
✓ Positive was executed (if)        if (isObject) {···
            assert('allExcept' in value, error);
        } else {
✓ Negative was executed (else)        } else {···
            assert(value === true, error);
        }
        if (isObject) {
            assert('allExcept' in value, error);
        } else {
            assert(value === true, error);
        }
        this._exceptions = {};
Branch IfStatement
✓ Positive was executed (if)        if (isObject) {···
            (value.allExcept || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);
        }
✓ Negative was executed (else)        }···
    },
        if (isObject) {
Function (anonymous_520)
✓ Was called            (value.allExcept || []).forEach(function(value) {···
                this._exceptions[value] = true;
            }, this);
Branch LogicalExpression
✓ Was returned            (value.allExcept || []).forEach(function(value) {
✓ Was returned            (value.allExcept || []).forEach(function(value) {
            (value.allExcept || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);
        }
    },
Function (anonymous_521)
✓ Was called    getOptionName: function() {···
        return 'disallowSpacesInsideBrackets';
    },
    getOptionName: function() {
        return 'disallowSpacesInsideBrackets';
    },
Function (anonymous_522)
✓ Was called    check: function(file, errors) {···
        var exceptions = this._exceptions;

        file.iterateTokenByValue('[', function(token) {
            var nextToken = file.getNextToken(token);
            var value = nextToken.value;

            if (value in exceptions) {
                return;
            }

            // Skip for empty array brackets
            if (value === ']') {
                return;
            }

            errors.assert.noWhitespaceBetween({
                token: token,
                nextToken: nextToken,
                message: 'Illegal space after opening bracket'
            });
        });

        file.iterateTokenByValue(']', function(token) {
            var prevToken = file.getPrevToken(token);
            var value = prevToken.value;

            if (value in exceptions) {
                return;
            }

            // Skip for empty array brackets
            if (value === '[') {
                return;
            }

            errors.assert.noWhitespaceBetween({
                token: prevToken,
                nextToken: token,
                message: 'Illegal space before closing bracket'
            });
        });
    }
    check: function(file, errors) {
        var exceptions = this._exceptions;
Function (anonymous_523)
✓ Was called        file.iterateTokenByValue('[', function(token) {···
            var nextToken = file.getNextToken(token);
            var value = nextToken.value;

            if (value in exceptions) {
                return;
            }

            // Skip for empty array brackets
            if (value === ']') {
                return;
            }

            errors.assert.noWhitespaceBetween({
                token: token,
                nextToken: nextToken,
                message: 'Illegal space after opening bracket'
            });
        });
        file.iterateTokenByValue('[', function(token) {
            var nextToken = file.getNextToken(token);
            var value = nextToken.value;
Branch IfStatement
✓ Positive was executed (if)            if (value in exceptions) {···
                return;
            }
✓ Negative was executed (else)            }···

            // Skip for empty array brackets
            if (value in exceptions) {
                return;
            }
            // Skip for empty array brackets
Branch IfStatement
✓ Positive was executed (if)            if (value === ']') {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.assert.noWhitespaceBetween({
            if (value === ']') {
                return;
            }
            errors.assert.noWhitespaceBetween({
                token: token,
                nextToken: nextToken,
                message: 'Illegal space after opening bracket'
            });
        });
Function (anonymous_524)
✓ Was called        file.iterateTokenByValue(']', function(token) {···
            var prevToken = file.getPrevToken(token);
            var value = prevToken.value;

            if (value in exceptions) {
                return;
            }

            // Skip for empty array brackets
            if (value === '[') {
                return;
            }

            errors.assert.noWhitespaceBetween({
                token: prevToken,
                nextToken: token,
                message: 'Illegal space before closing bracket'
            });
        });
        file.iterateTokenByValue(']', function(token) {
            var prevToken = file.getPrevToken(token);
            var value = prevToken.value;
Branch IfStatement
✓ Positive was executed (if)            if (value in exceptions) {···
                return;
            }
✓ Negative was executed (else)            }···

            // Skip for empty array brackets
            if (value in exceptions) {
                return;
            }
            // Skip for empty array brackets
Branch IfStatement
✓ Positive was executed (if)            if (value === '[') {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.assert.noWhitespaceBetween({
            if (value === '[') {
                return;
            }
            errors.assert.noWhitespaceBetween({
                token: prevToken,
                nextToken: token,
                message: 'Illegal space before closing bracket'
            });
        });
    }
};

disallow-spaces-inside-object-brackets.js
/**
 * Disallows space after opening object curly brace and before closing.
 *
 * Types: `Object`, `Boolean` or `String`
 *
 * Values: `"all"` or `true` for strict mode, `"nested"` (*deprecated* use `"allExcept": ['}']`)
 * ignores closing brackets in a row.
 *
 * #### Example
 *
 * ```js
 * "disallowSpacesInsideObjectBrackets": {
 *     "allExcept": [ "}", ")" ]
 * }
 *
 * // or
 * "disallowSpacesInsideObjectBrackets": true | "all" | "nested"
 * ```
 *
 * ##### Valid for mode `"all"`
 *
 * ```js
 * var x = {a: {b: 1}};
 * ```
 *
 * ##### Valid for mode `"nested"`
 *
 * ```js
 * var x = {a: {b: 1} };
 * ```
 *
 * ##### Valid for mode `"allExcept": ["}"]`
 *
 * ```js
 * var x = {a: {b: 1} };
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = { a: { b: 1 } };
 * ```
 */
var assert = require('assert');
Function (anonymous_525)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_526)
✓ Was called    configure: function(value) {···
        var mode;
        var modes = {
            'all': true,
            'nested': true
        };
        var isObject = typeof value === 'object';

        var error = this.getOptionName() + ' rule' +
        ' requires string "all" or "nested", true value or object';

        if (typeof value === 'string' || value === true) {
            assert(modes[value === true ? 'all' : value], error);

        } else if (isObject) {
            assert('allExcept' in value, error);
        } else {
            assert(false, error);
        }

        this._exceptions = {};

        if (isObject) {
            (value.allExcept || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);

        } else {
            mode = value;
        }

        if (mode === 'nested') {
            this._exceptions['}'] = true;
        }
    },
    configure: function(value) {
        var mode;
        var modes = {
            'all': true,
            'nested': true
        };
        var isObject = typeof value === 'object';
        var error = this.getOptionName() + ' rule' +
        ' requires string "all" or "nested", true value or object';
Branch IfStatement
✓ Positive was executed (if)        if (typeof value === 'string' || value === true) {···
            assert(modes[value === true ? 'all' : value], error);

        } else if (isObject) {
✓ Negative was executed (else)        } else if (isObject) {···
            assert('allExcept' in value, error);
        } else {
            assert(false, error);
        }
Branch LogicalExpression
✓ Was returned        if (typeof value === 'string' || value === true) {
✓ Was returned        if (typeof value === 'string' || value === true) {
        if (typeof value === 'string' || value === true) {
Branch ConditionalExpression
✓ Positive was returned (? ...)            assert(modes[value === true ? 'all' : value], error);
✓ Negative was returned (: ...)            assert(modes[value === true ? 'all' : value], error);
            assert(modes[value === true ? 'all' : value], error);
Branch IfStatement
✓ Positive was executed (if)        } else if (isObject) {···
            assert('allExcept' in value, error);
        } else {
✓ Negative was executed (else)        } else {···
            assert(false, error);
        }
        } else if (isObject) {
            assert('allExcept' in value, error);
        } else {
            assert(false, error);
        }
        this._exceptions = {};
Branch IfStatement
✓ Positive was executed (if)        if (isObject) {···
            (value.allExcept || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);

        } else {
✓ Negative was executed (else)        } else {···
            mode = value;
        }
        if (isObject) {
Function (anonymous_527)
✓ Was called            (value.allExcept || []).forEach(function(value) {···
                this._exceptions[value] = true;
            }, this);
Branch LogicalExpression
✓ Was returned            (value.allExcept || []).forEach(function(value) {
✓ Was returned            (value.allExcept || []).forEach(function(value) {
            (value.allExcept || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);
        } else {
            mode = value;
        }
Branch IfStatement
✓ Positive was executed (if)        if (mode === 'nested') {···
            this._exceptions['}'] = true;
        }
✓ Negative was executed (else)        }···
    },
        if (mode === 'nested') {
            this._exceptions['}'] = true;
        }
    },
Function (anonymous_528)
✓ Was called    getOptionName: function() {···
        return 'disallowSpacesInsideObjectBrackets';
    },
    getOptionName: function() {
        return 'disallowSpacesInsideObjectBrackets';
    },
Function (anonymous_529)
✓ Was called    check: function(file, errors) {···
        var exceptions = this._exceptions;

        file.iterateNodesByType('ObjectExpression', function(node) {
            var openingBracket = file.getFirstNodeToken(node);
            var nextToken = file.getNextToken(openingBracket);

            errors.assert.noWhitespaceBetween({
                token: openingBracket,
                nextToken: nextToken,
                message: 'Illegal space after opening curly brace'
            });

            var closingBracket = file.getLastNodeToken(node);
            var prevToken = file.getPrevToken(closingBracket);

            if (prevToken.value in exceptions) {
                return;
            }

            errors.assert.noWhitespaceBetween({
                token: prevToken,
                nextToken: closingBracket,
                message: 'Illegal space before closing curly brace'
            });
        });
    }
    check: function(file, errors) {
        var exceptions = this._exceptions;
Function (anonymous_530)
✓ Was called        file.iterateNodesByType('ObjectExpression', function(node) {···
            var openingBracket = file.getFirstNodeToken(node);
            var nextToken = file.getNextToken(openingBracket);

            errors.assert.noWhitespaceBetween({
                token: openingBracket,
                nextToken: nextToken,
                message: 'Illegal space after opening curly brace'
            });

            var closingBracket = file.getLastNodeToken(node);
            var prevToken = file.getPrevToken(closingBracket);

            if (prevToken.value in exceptions) {
                return;
            }

            errors.assert.noWhitespaceBetween({
                token: prevToken,
                nextToken: closingBracket,
                message: 'Illegal space before closing curly brace'
            });
        });
        file.iterateNodesByType('ObjectExpression', function(node) {
            var openingBracket = file.getFirstNodeToken(node);
            var nextToken = file.getNextToken(openingBracket);
            errors.assert.noWhitespaceBetween({
                token: openingBracket,
                nextToken: nextToken,
                message: 'Illegal space after opening curly brace'
            });
            var closingBracket = file.getLastNodeToken(node);
            var prevToken = file.getPrevToken(closingBracket);
Branch IfStatement
✓ Positive was executed (if)            if (prevToken.value in exceptions) {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.assert.noWhitespaceBetween({
            if (prevToken.value in exceptions) {
                return;
            }
            errors.assert.noWhitespaceBetween({
                token: prevToken,
                nextToken: closingBracket,
                message: 'Illegal space before closing curly brace'
            });
        });
    }
};

disallow-spaces-inside-array-brackets.js
/**
 * Disallows space after opening array square bracket and before closing.
 *
 * Types: `Boolean`, `String` or `Object`
 *
 * Values: `"all"` or `true` for strict mode, `"nested"` (*deprecated* use `"allExcept": [ "[", "]" ]`)
 * ignores closing brackets in a row.
 *
 * #### Example
 *
 * ```js
 * "disallowSpacesInsideArrayBrackets": "all"
 *
 * // or
 *
 * "disallowSpacesInsideArrayBrackets": {
 *     "allExcept": [ "[", "]", "{", "}" ]
 * }
 * ```
 *
 * ##### Valid for mode `"all"`
 *
 * ```js
 * var x = [[1]];
 * ```
 *
 *
 * ##### Valid for mode `"nested"`
 *
 * ```js
 * var x = [ [1] ];
 * ```
 *
 * ##### Valid for mode `"allExcept"`
 *
 * ```js
 * var x = [ [1] ];
 * var x = [ { a: 1 } ];
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = [ [ 1 ] ];
 * ```
 */
var assert = require('assert');
Function (anonymous_531)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_532)
✓ Was called    configure: function(value) {···
        var mode;
        var modes = {
            'all': true,
            'nested': true
        };
        var isObject = typeof value === 'object';

        var error = this.getOptionName() + ' rule' +
        ' requires string value "all" or "nested" or object';

        if (typeof value === 'string' || value === true) {
            assert(modes[value === true ? 'all' : value], error);

        } else if (isObject) {
            assert('allExcept' in value, error);
        } else {
            assert(false, error);
        }

        this._exceptions = {};

        if (isObject) {
            (value.allExcept || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);

        } else {
            mode = value;
        }

        if (mode === 'nested') {
            this._exceptions['['] = this._exceptions[']'] = true;
        }
    },
    configure: function(value) {
        var mode;
        var modes = {
            'all': true,
            'nested': true
        };
        var isObject = typeof value === 'object';
        var error = this.getOptionName() + ' rule' +
        ' requires string value "all" or "nested" or object';
Branch IfStatement
✓ Positive was executed (if)        if (typeof value === 'string' || value === true) {···
            assert(modes[value === true ? 'all' : value], error);

        } else if (isObject) {
✓ Negative was executed (else)        } else if (isObject) {···
            assert('allExcept' in value, error);
        } else {
            assert(false, error);
        }
Branch LogicalExpression
✓ Was returned        if (typeof value === 'string' || value === true) {
✓ Was returned        if (typeof value === 'string' || value === true) {
        if (typeof value === 'string' || value === true) {
Branch ConditionalExpression
✓ Positive was returned (? ...)            assert(modes[value === true ? 'all' : value], error);
✓ Negative was returned (: ...)            assert(modes[value === true ? 'all' : value], error);
            assert(modes[value === true ? 'all' : value], error);
Branch IfStatement
✓ Positive was executed (if)        } else if (isObject) {···
            assert('allExcept' in value, error);
        } else {
✓ Negative was executed (else)        } else {···
            assert(false, error);
        }
        } else if (isObject) {
            assert('allExcept' in value, error);
        } else {
            assert(false, error);
        }
        this._exceptions = {};
Branch IfStatement
✓ Positive was executed (if)        if (isObject) {···
            (value.allExcept || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);

        } else {
✓ Negative was executed (else)        } else {···
            mode = value;
        }
        if (isObject) {
Function (anonymous_533)
✓ Was called            (value.allExcept || []).forEach(function(value) {···
                this._exceptions[value] = true;
            }, this);
Branch LogicalExpression
✓ Was returned            (value.allExcept || []).forEach(function(value) {
✓ Was returned            (value.allExcept || []).forEach(function(value) {
            (value.allExcept || []).forEach(function(value) {
                this._exceptions[value] = true;
            }, this);
        } else {
            mode = value;
        }
Branch IfStatement
✓ Positive was executed (if)        if (mode === 'nested') {···
            this._exceptions['['] = this._exceptions[']'] = true;
        }
✓ Negative was executed (else)        }···
    },
        if (mode === 'nested') {
            this._exceptions['['] = this._exceptions[']'] = true;
        }
    },
Function (anonymous_534)
✓ Was called    getOptionName: function() {···
        return 'disallowSpacesInsideArrayBrackets';
    },
    getOptionName: function() {
        return 'disallowSpacesInsideArrayBrackets';
    },
Function (anonymous_535)
✓ Was called    check: function(file, errors) {···
        var exceptions = this._exceptions;

        file.iterateNodesByType('ArrayExpression', function(node) {
            var openBracket = file.getFirstNodeToken(node);
            var afterOpen = file.getNextToken(openBracket, {includeComments: true});
            var closeBracket = file.getLastNodeToken(node);
            var beforeClose = file.getPrevToken(closeBracket, {includeComments: true});

            // Skip for empty array brackets
            if (afterOpen.value === ']') {
                return;
            }

            if (!(afterOpen.value in exceptions)) {
                errors.assert.noWhitespaceBetween({
                    token: openBracket,
                    nextToken: afterOpen,
                    message: 'Illegal space after opening bracket'
                });
            }

            if (!(beforeClose.value in exceptions)) {
                errors.assert.noWhitespaceBetween({
                    token: beforeClose,
                    nextToken: closeBracket,
                    message: 'Illegal space before closing bracket'
                });
            }
        });
    }
    check: function(file, errors) {
        var exceptions = this._exceptions;
Function (anonymous_536)
✓ Was called        file.iterateNodesByType('ArrayExpression', function(node) {···
            var openBracket = file.getFirstNodeToken(node);
            var afterOpen = file.getNextToken(openBracket, {includeComments: true});
            var closeBracket = file.getLastNodeToken(node);
            var beforeClose = file.getPrevToken(closeBracket, {includeComments: true});

            // Skip for empty array brackets
            if (afterOpen.value === ']') {
                return;
            }

            if (!(afterOpen.value in exceptions)) {
                errors.assert.noWhitespaceBetween({
                    token: openBracket,
                    nextToken: afterOpen,
                    message: 'Illegal space after opening bracket'
                });
            }

            if (!(beforeClose.value in exceptions)) {
                errors.assert.noWhitespaceBetween({
                    token: beforeClose,
                    nextToken: closeBracket,
                    message: 'Illegal space before closing bracket'
                });
            }
        });
        file.iterateNodesByType('ArrayExpression', function(node) {
            var openBracket = file.getFirstNodeToken(node);
            var afterOpen = file.getNextToken(openBracket, {includeComments: true});
            var closeBracket = file.getLastNodeToken(node);
            var beforeClose = file.getPrevToken(closeBracket, {includeComments: true});
            // Skip for empty array brackets
Branch IfStatement
✓ Positive was executed (if)            if (afterOpen.value === ']') {···
                return;
            }
✓ Negative was executed (else)            }···

            if (!(afterOpen.value in exceptions)) {
            if (afterOpen.value === ']') {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (!(afterOpen.value in exceptions)) {···
                errors.assert.noWhitespaceBetween({
                    token: openBracket,
                    nextToken: afterOpen,
                    message: 'Illegal space after opening bracket'
                });
            }
✓ Negative was executed (else)            }···

            if (!(beforeClose.value in exceptions)) {
            if (!(afterOpen.value in exceptions)) {
                errors.assert.noWhitespaceBetween({
                    token: openBracket,
                    nextToken: afterOpen,
                    message: 'Illegal space after opening bracket'
                });
            }
Branch IfStatement
✓ Positive was executed (if)            if (!(beforeClose.value in exceptions)) {···
                errors.assert.noWhitespaceBetween({
                    token: beforeClose,
                    nextToken: closeBracket,
                    message: 'Illegal space before closing bracket'
                });
            }
✓ Negative was executed (else)            }···
        });
            if (!(beforeClose.value in exceptions)) {
                errors.assert.noWhitespaceBetween({
                    token: beforeClose,
                    nextToken: closeBracket,
                    message: 'Illegal space before closing bracket'
                });
            }
        });
    }
};

disallow-spaces-inside-parentheses.js
/**
 * Disallows space after opening round bracket and before closing.
 *
 * Types: `Object` or `Boolean`
 *
 * Values: Either `true` or Object with `"only"` property as an array of tokens
 *
 * #### Example
 *
 * ```js
 * "disallowSpacesInsideParentheses": true
 * ```
 *
 * ##### Valid for `true` value
 *
 * ```js
 * var x = (1 + 2) * 3;
 * ```
 *
 * ##### Valid for `only` value
 *
 * ```js
 * "disallowSpacesInsideParentheses": { "only": [ "{", "}" ] }
 * ```
 *
 * ```js
 * var x = ( 1 + 2 );
 * var x = foo({});
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = foo( {} );
 * ```
 */
var assert = require('assert');
Function (anonymous_537)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_538)
✓ Was called    configure: function(option) {···
        var isObject = typeof option === 'object';

        var error = this.getOptionName() + ' option requires' +
            ' true or object value with "only" properties ';

        // backcompat for 1.10: {all: true} #1027
        if (isObject && option.all === true) {
            option = true;
        }

        if (typeof option === 'boolean') {
            assert(option === true, error);
        } else if (isObject) {
            assert('only' in option, error);
        } else {
            assert(false, error);
        }

        if (option.only) {
            this._only = {};
            (option.only).forEach(function(value) {
                this._only[value] = true;
            }, this);
        } else {
            this._only = null;
        }
    },
    configure: function(option) {
        var isObject = typeof option === 'object';
        var error = this.getOptionName() + ' option requires' +
            ' true or object value with "only" properties ';
        // backcompat for 1.10: {all: true} #1027
Branch IfStatement
✓ Positive was executed (if)        if (isObject && option.all === true) {···
            option = true;
        }
✓ Negative was executed (else)        }···

        if (typeof option === 'boolean') {
Branch LogicalExpression
✓ Was returned        if (isObject && option.all === true) {
✓ Was returned        if (isObject && option.all === true) {
        if (isObject && option.all === true) {
            option = true;
        }
Branch IfStatement
✓ Positive was executed (if)        if (typeof option === 'boolean') {···
            assert(option === true, error);
        } else if (isObject) {
✓ Negative was executed (else)        } else if (isObject) {···
            assert('only' in option, error);
        } else {
            assert(false, error);
        }
        if (typeof option === 'boolean') {
            assert(option === true, error);
Branch IfStatement
✓ Positive was executed (if)        } else if (isObject) {···
            assert('only' in option, error);
        } else {
✓ Negative was executed (else)        } else {···
            assert(false, error);
        }
        } else if (isObject) {
            assert('only' in option, error);
        } else {
            assert(false, error);
        }
Branch IfStatement
✓ Positive was executed (if)        if (option.only) {···
            this._only = {};
            (option.only).forEach(function(value) {
                this._only[value] = true;
            }, this);
        } else {
✓ Negative was executed (else)        } else {···
            this._only = null;
        }
        if (option.only) {
            this._only = {};
Function (anonymous_539)
✓ Was called            (option.only).forEach(function(value) {···
                this._only[value] = true;
            }, this);
            (option.only).forEach(function(value) {
                this._only[value] = true;
            }, this);
        } else {
            this._only = null;
        }
    },
Function (anonymous_540)
✓ Was called    getOptionName: function() {···
        return 'disallowSpacesInsideParentheses';
    },
    getOptionName: function() {
        return 'disallowSpacesInsideParentheses';
    },
Function (anonymous_541)
✓ Was called    check: function(file, errors) {···
        var only = this._only;

        file.iterateTokenByValue('(', function(token) {
            var nextToken = file.getNextToken(token, {includeComments: true});
            var value = nextToken.value;

            if (only && !(value in only)) {
                return;
            }

            errors.assert.noWhitespaceBetween({
                token: token,
                nextToken: nextToken,
                message: 'Illegal space after opening round bracket'
            });
        });

        file.iterateTokenByValue(')', function(token) {
            var prevToken = file.getPrevToken(token, {includeComments: true});
            var value = prevToken.value;

            if (only) {
                if (!(value in only)) {
                    return;
                }

                if (
                    value === ']' &&
                    file.getNodeByRange(prevToken.range[0]).type === 'MemberExpression'
                ) {
                    return;
                }
            }

            errors.assert.noWhitespaceBetween({
                token: prevToken,
                nextToken: token,
                message: 'Illegal space before closing round bracket'
            });
        });
    }
    check: function(file, errors) {
        var only = this._only;
Function (anonymous_542)
✓ Was called        file.iterateTokenByValue('(', function(token) {···
            var nextToken = file.getNextToken(token, {includeComments: true});
            var value = nextToken.value;

            if (only && !(value in only)) {
                return;
            }

            errors.assert.noWhitespaceBetween({
                token: token,
                nextToken: nextToken,
                message: 'Illegal space after opening round bracket'
            });
        });
        file.iterateTokenByValue('(', function(token) {
            var nextToken = file.getNextToken(token, {includeComments: true});
            var value = nextToken.value;
Branch IfStatement
✓ Positive was executed (if)            if (only && !(value in only)) {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.assert.noWhitespaceBetween({
Branch LogicalExpression
✓ Was returned            if (only && !(value in only)) {
✓ Was returned            if (only && !(value in only)) {
            if (only && !(value in only)) {
                return;
            }
            errors.assert.noWhitespaceBetween({
                token: token,
                nextToken: nextToken,
                message: 'Illegal space after opening round bracket'
            });
        });
Function (anonymous_543)
✓ Was called        file.iterateTokenByValue(')', function(token) {···
            var prevToken = file.getPrevToken(token, {includeComments: true});
            var value = prevToken.value;

            if (only) {
                if (!(value in only)) {
                    return;
                }

                if (
                    value === ']' &&
                    file.getNodeByRange(prevToken.range[0]).type === 'MemberExpression'
                ) {
                    return;
                }
            }

            errors.assert.noWhitespaceBetween({
                token: prevToken,
                nextToken: token,
                message: 'Illegal space before closing round bracket'
            });
        });
        file.iterateTokenByValue(')', function(token) {
            var prevToken = file.getPrevToken(token, {includeComments: true});
            var value = prevToken.value;
Branch IfStatement
✓ Positive was executed (if)            if (only) {···
                if (!(value in only)) {
                    return;
                }

                if (
                    value === ']' &&
                    file.getNodeByRange(prevToken.range[0]).type === 'MemberExpression'
                ) {
                    return;
                }
            }
✓ Negative was executed (else)            }···

            errors.assert.noWhitespaceBetween({
            if (only) {
Branch IfStatement
✓ Positive was executed (if)                if (!(value in only)) {···
                    return;
                }
✓ Negative was executed (else)                }···

                if (
                if (!(value in only)) {
                    return;
                }
Branch IfStatement
✓ Positive was executed (if)                ) {···
                    return;
                }
✓ Negative was executed (else)                }···
            }
                if (
Branch LogicalExpression
✓ Was returned                    file.getNodeByRange(prevToken.range[0]).type === 'MemberExpression'
✓ Was returned                    value === ']' &&
                    value === ']' &&
                    file.getNodeByRange(prevToken.range[0]).type === 'MemberExpression'
                ) {
                    return;
                }
            }
            errors.assert.noWhitespaceBetween({
                token: prevToken,
                nextToken: token,
                message: 'Illegal space before closing round bracket'
            });
        });
    }
};

require-blocks-on-newline.js
/**
 * Requires blocks to begin and end with a newline
 *
 * Types: `Boolean` or `Integer`
 *
 * Values: `true` validates all non-empty blocks,
 * `Integer` specifies a minimum number of statements in the block before validating.
 *
 * #### Example
 *
 * ```js
 * "requireBlocksOnNewline": true
 * ```
 *
 * ##### Valid for mode `true`
 *
 * ```js
 * if (true) {
 *     doSomething();
 * }
 * var abc = function() {};
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * if (true) {doSomething();}
 * ```
 *
 * ##### Valid for mode `1`
 *
 * ```js
 * if (true) {
 *     doSomething();
 *     doSomethingElse();
 * }
 * if (true) { doSomething(); }
 * var abc = function() {};
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * if (true) { doSomething(); doSomethingElse(); }
 * ```
 */
var assert = require('assert');
Function (anonymous_544)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_545)
✓ Was called    configure: function(options) {···
        assert(
            options === true || typeof options === 'number',
            this.getOptionName() + ' option requires the value true or an Integer'
        );

        this._minStatements = options === true ? 0 : options;
    },
    configure: function(options) {
        assert(
Branch LogicalExpression
✓ Was returned            options === true || typeof options === 'number',
✓ Was returned            options === true || typeof options === 'number',
            options === true || typeof options === 'number',
            this.getOptionName() + ' option requires the value true or an Integer'
        );
Branch ConditionalExpression
✓ Positive was returned (? ...)        this._minStatements = options === true ? 0 : options;
✓ Negative was returned (: ...)        this._minStatements = options === true ? 0 : options;
        this._minStatements = options === true ? 0 : options;
    },
Function (anonymous_546)
✓ Was called    getOptionName: function() {···
        return 'requireBlocksOnNewline';
    },
    getOptionName: function() {
        return 'requireBlocksOnNewline';
    },
Function (anonymous_547)
✓ Was called    check: function(file, errors) {···
        var minStatements = this._minStatements;

        file.iterateNodesByType('BlockStatement', function(node) {
            if (node.body.length <= minStatements) {
                return;
            }

            var openingBracket = file.getFirstNodeToken(node);
            var nextToken = file.getNextToken(openingBracket);

            errors.assert.differentLine({
                token: openingBracket,
                nextToken: nextToken,
                message: 'Missing newline after opening curly brace'
            });

            var closingBracket = file.getLastNodeToken(node);
            var prevToken = file.getPrevToken(closingBracket);

            errors.assert.differentLine({
                token: prevToken,
                nextToken: closingBracket,
                message: 'Missing newline before closing curly brace'
            });
        });
    }
    check: function(file, errors) {
        var minStatements = this._minStatements;
Function (anonymous_548)
✓ Was called        file.iterateNodesByType('BlockStatement', function(node) {···
            if (node.body.length <= minStatements) {
                return;
            }

            var openingBracket = file.getFirstNodeToken(node);
            var nextToken = file.getNextToken(openingBracket);

            errors.assert.differentLine({
                token: openingBracket,
                nextToken: nextToken,
                message: 'Missing newline after opening curly brace'
            });

            var closingBracket = file.getLastNodeToken(node);
            var prevToken = file.getPrevToken(closingBracket);

            errors.assert.differentLine({
                token: prevToken,
                nextToken: closingBracket,
                message: 'Missing newline before closing curly brace'
            });
        });
        file.iterateNodesByType('BlockStatement', function(node) {
Branch IfStatement
✓ Positive was executed (if)            if (node.body.length <= minStatements) {···
                return;
            }
✓ Negative was executed (else)            }···

            var openingBracket = file.getFirstNodeToken(node);
            if (node.body.length <= minStatements) {
                return;
            }
            var openingBracket = file.getFirstNodeToken(node);
            var nextToken = file.getNextToken(openingBracket);
            errors.assert.differentLine({
                token: openingBracket,
                nextToken: nextToken,
                message: 'Missing newline after opening curly brace'
            });
            var closingBracket = file.getLastNodeToken(node);
            var prevToken = file.getPrevToken(closingBracket);
            errors.assert.differentLine({
                token: prevToken,
                nextToken: closingBracket,
                message: 'Missing newline before closing curly brace'
            });
        });
    }
};

require-space-after-object-keys.js
/**
 * Requires space after object keys.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "requireSpaceAfterObjectKeys": true
 * ```
 *
 * ##### Valid
 * ```js
 * var x = {a : 1};
 * ```
 * ##### Invalid
 * ```js
 * var x = {a: 1};
 * ```
 */
var assert = require('assert');
Function (anonymous_549)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_550)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_551)
✓ Was called    getOptionName: function() {···
        return 'requireSpaceAfterObjectKeys';
    },
    getOptionName: function() {
        return 'requireSpaceAfterObjectKeys';
    },
Function (anonymous_552)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('ObjectExpression', function(node) {
            node.properties.forEach(function(property) {
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return;
                }

                var token = file.getFirstNodeToken(property.key);
                errors.assert.whitespaceBetween({
                    token: token,
                    nextToken: file.getNextToken(token),
                    message: 'Missing space after key'
                });
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_553)
✓ Was called        file.iterateNodesByType('ObjectExpression', function(node) {···
            node.properties.forEach(function(property) {
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return;
                }

                var token = file.getFirstNodeToken(property.key);
                errors.assert.whitespaceBetween({
                    token: token,
                    nextToken: file.getNextToken(token),
                    message: 'Missing space after key'
                });
            });
        });
        file.iterateNodesByType('ObjectExpression', function(node) {
Function (anonymous_554)
✓ Was called            node.properties.forEach(function(property) {···
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return;
                }

                var token = file.getFirstNodeToken(property.key);
                errors.assert.whitespaceBetween({
                    token: token,
                    nextToken: file.getNextToken(token),
                    message: 'Missing space after key'
                });
            });
            node.properties.forEach(function(property) {
Branch IfStatement
✓ Positive was executed (if)                if (property.shorthand || property.method || property.kind !== 'init') {···
                    return;
                }
✓ Negative was executed (else)                }···

                var token = file.getFirstNodeToken(property.key);
Branch LogicalExpression
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
Branch LogicalExpression
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return;
                }
                var token = file.getFirstNodeToken(property.key);
                errors.assert.whitespaceBetween({
                    token: token,
                    nextToken: file.getNextToken(token),
                    message: 'Missing space after key'
                });
            });
        });
    }
};

require-space-before-object-values.js
/**
 * Requires space after object keys.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "requireSpaceBeforeObjectValues": true
 * ```
 *
 * ##### Valid
 * ```js
 * var x = {a: 1};
 * ```
 * ##### Invalid
 * ```js
 * var x = {a:1};
 * ```
 */
var assert = require('assert');
Function (anonymous_555)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_556)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_557)
✓ Was called    getOptionName: function() {···
        return 'requireSpaceBeforeObjectValues';
    },
    getOptionName: function() {
        return 'requireSpaceBeforeObjectValues';
    },
Function (anonymous_558)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('ObjectExpression', function(node) {
            node.properties.forEach(function(property) {
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return;
                }

                var keyToken = file.getFirstNodeToken(property.key);
                var colon = file.findNextToken(keyToken, 'Punctuator', ':');

                errors.assert.whitespaceBetween({
                    token: colon,
                    nextToken: file.getNextToken(colon),
                    message: 'Missing space after key colon'
                });
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_559)
✓ Was called        file.iterateNodesByType('ObjectExpression', function(node) {···
            node.properties.forEach(function(property) {
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return;
                }

                var keyToken = file.getFirstNodeToken(property.key);
                var colon = file.findNextToken(keyToken, 'Punctuator', ':');

                errors.assert.whitespaceBetween({
                    token: colon,
                    nextToken: file.getNextToken(colon),
                    message: 'Missing space after key colon'
                });
            });
        });
        file.iterateNodesByType('ObjectExpression', function(node) {
Function (anonymous_560)
✓ Was called            node.properties.forEach(function(property) {···
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return;
                }

                var keyToken = file.getFirstNodeToken(property.key);
                var colon = file.findNextToken(keyToken, 'Punctuator', ':');

                errors.assert.whitespaceBetween({
                    token: colon,
                    nextToken: file.getNextToken(colon),
                    message: 'Missing space after key colon'
                });
            });
            node.properties.forEach(function(property) {
Branch IfStatement
✓ Positive was executed (if)                if (property.shorthand || property.method || property.kind !== 'init') {···
                    return;
                }
✓ Negative was executed (else)                }···

                var keyToken = file.getFirstNodeToken(property.key);
Branch LogicalExpression
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
Branch LogicalExpression
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return;
                }
                var keyToken = file.getFirstNodeToken(property.key);
                var colon = file.findNextToken(keyToken, 'Punctuator', ':');
                errors.assert.whitespaceBetween({
                    token: colon,
                    nextToken: file.getNextToken(colon),
                    message: 'Missing space after key colon'
                });
            });
        });
    }
};

disallow-space-after-object-keys.js
/**
 * Disallows space after object keys.
 *
 * Types: `Boolean` or `String`
 *
 * Values:
 *  - `true`
 *  - `"ignoreSingleLine"` ignores objects if the object only takes up a single line
 *  - `"ignoreMultiLine"` ignores objects if the object takes up multiple lines
 *
 * #### Example
 *
 * ```js
 * "disallowSpaceAfterObjectKeys": true
 * ```
 *
 * ##### Valid
 * ```js
 * var x = {a: 1};
 * ```
 * ##### Invalid
 * ```js
 * var x = {a : 1};
 * ```
 */
var assert = require('assert');
Function (anonymous_561)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_562)
✓ Was called    configure: function(disallow) {···
        var modes = {
            'ignoreSingleLine': 'ignoreSingleLine',
            'ignoreMultiLine': 'ignoreMultiLine'
        };
        assert(
            disallow === true || typeof disallow === 'string' && modes[disallow],
            this.getOptionName() +
            ' option requires true value requires one of the following values: ' +
            Object.keys(modes).join(', ')
        );
        this._mode = disallow === true ? true : modes[disallow];
    },
    configure: function(disallow) {
        var modes = {
            'ignoreSingleLine': 'ignoreSingleLine',
            'ignoreMultiLine': 'ignoreMultiLine'
        };
        assert(
Branch LogicalExpression
✓ Was returned            disallow === true || typeof disallow === 'string' && modes[disallow],
✓ Was returned            disallow === true || typeof disallow === 'string' && modes[disallow],
Branch LogicalExpression
✓ Was returned            disallow === true || typeof disallow === 'string' && modes[disallow],
✗ Was not returned            disallow === true || typeof disallow === 'string' && modes[disallow],
            disallow === true || typeof disallow === 'string' && modes[disallow],
            this.getOptionName() +
            ' option requires true value requires one of the following values: ' +
            Object.keys(modes).join(', ')
        );
Branch ConditionalExpression
✓ Positive was returned (? ...)        this._mode = disallow === true ? true : modes[disallow];
✓ Negative was returned (: ...)        this._mode = disallow === true ? true : modes[disallow];
        this._mode = disallow === true ? true : modes[disallow];
    },
Function (anonymous_563)
✓ Was called    getOptionName: function() {···
        return 'disallowSpaceAfterObjectKeys';
    },
    getOptionName: function() {
        return 'disallowSpaceAfterObjectKeys';
    },
Function (anonymous_564)
✓ Was called    check: function(file, errors) {···
        var mode = this._mode;
        file.iterateNodesByType('ObjectExpression', function(node) {
            node.properties.forEach(function(property) {
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return;
                }
                if (mode === 'ignoreSingleLine' && node.loc.start.line === node.loc.end.line) {
                    return;
                }
                if (mode === 'ignoreMultiLine' && node.loc.start.line !== node.loc.end.line) {
                    return;
                }

                var token = file.getFirstNodeToken(property.key);
                errors.assert.noWhitespaceBetween({
                    token: token,
                    nextToken: file.getNextToken(token),
                    message: 'Illegal space after key',
                    disallowNewLine: true
                });
            });
        });
    }
    check: function(file, errors) {
        var mode = this._mode;
Function (anonymous_565)
✓ Was called        file.iterateNodesByType('ObjectExpression', function(node) {···
            node.properties.forEach(function(property) {
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return;
                }
                if (mode === 'ignoreSingleLine' && node.loc.start.line === node.loc.end.line) {
                    return;
                }
                if (mode === 'ignoreMultiLine' && node.loc.start.line !== node.loc.end.line) {
                    return;
                }

                var token = file.getFirstNodeToken(property.key);
                errors.assert.noWhitespaceBetween({
                    token: token,
                    nextToken: file.getNextToken(token),
                    message: 'Illegal space after key',
                    disallowNewLine: true
                });
            });
        });
        file.iterateNodesByType('ObjectExpression', function(node) {
Function (anonymous_566)
✓ Was called            node.properties.forEach(function(property) {···
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return;
                }
                if (mode === 'ignoreSingleLine' && node.loc.start.line === node.loc.end.line) {
                    return;
                }
                if (mode === 'ignoreMultiLine' && node.loc.start.line !== node.loc.end.line) {
                    return;
                }

                var token = file.getFirstNodeToken(property.key);
                errors.assert.noWhitespaceBetween({
                    token: token,
                    nextToken: file.getNextToken(token),
                    message: 'Illegal space after key',
                    disallowNewLine: true
                });
            });
            node.properties.forEach(function(property) {
Branch IfStatement
✓ Positive was executed (if)                if (property.shorthand || property.method || property.kind !== 'init') {···
                    return;
                }
✓ Negative was executed (else)                }···
                if (mode === 'ignoreSingleLine' && node.loc.start.line === node.loc.end.line) {
Branch LogicalExpression
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
Branch LogicalExpression
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return;
                }
Branch IfStatement
✓ Positive was executed (if)                if (mode === 'ignoreSingleLine' && node.loc.start.line === node.loc.end.line) {···
                    return;
                }
✓ Negative was executed (else)                }···
                if (mode === 'ignoreMultiLine' && node.loc.start.line !== node.loc.end.line) {
Branch LogicalExpression
✓ Was returned                if (mode === 'ignoreSingleLine' && node.loc.start.line === node.loc.end.line) {
✓ Was returned                if (mode === 'ignoreSingleLine' && node.loc.start.line === node.loc.end.line) {
                if (mode === 'ignoreSingleLine' && node.loc.start.line === node.loc.end.line) {
                    return;
                }
Branch IfStatement
✓ Positive was executed (if)                if (mode === 'ignoreMultiLine' && node.loc.start.line !== node.loc.end.line) {···
                    return;
                }
✓ Negative was executed (else)                }···

                var token = file.getFirstNodeToken(property.key);
Branch LogicalExpression
✓ Was returned                if (mode === 'ignoreMultiLine' && node.loc.start.line !== node.loc.end.line) {
✓ Was returned                if (mode === 'ignoreMultiLine' && node.loc.start.line !== node.loc.end.line) {
                if (mode === 'ignoreMultiLine' && node.loc.start.line !== node.loc.end.line) {
                    return;
                }
                var token = file.getFirstNodeToken(property.key);
                errors.assert.noWhitespaceBetween({
                    token: token,
                    nextToken: file.getNextToken(token),
                    message: 'Illegal space after key',
                    disallowNewLine: true
                });
            });
        });
    }
};

disallow-space-before-object-values.js
/**
 * Disallows space after object keys.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowSpaceBeforeObjectValues": true
 * ```
 *
 * ##### Valid
 * ```js
 * var x = {a:1};
 * ```
 * ##### Invalid
 * ```js
 * var x = {a: 1};
 * ```
 */
var assert = require('assert');
Function (anonymous_567)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_568)
✓ Was called    configure: function(disallow) {···
        assert(
            disallow === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(disallow) {
        assert(
            disallow === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_569)
✓ Was called    getOptionName: function() {···
        return 'disallowSpaceBeforeObjectValues';
    },
    getOptionName: function() {
        return 'disallowSpaceBeforeObjectValues';
    },
Function (anonymous_570)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('ObjectExpression', function(node) {
            node.properties.forEach(function(property) {
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return;
                }

                var keyToken = file.getFirstNodeToken(property.key);
                var colon = file.findNextToken(keyToken, 'Punctuator', ':');

                errors.assert.noWhitespaceBetween({
                    token: colon,
                    nextToken: file.getNextToken(colon),
                    message: 'Illegal space after key colon'
                });
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_571)
✓ Was called        file.iterateNodesByType('ObjectExpression', function(node) {···
            node.properties.forEach(function(property) {
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return;
                }

                var keyToken = file.getFirstNodeToken(property.key);
                var colon = file.findNextToken(keyToken, 'Punctuator', ':');

                errors.assert.noWhitespaceBetween({
                    token: colon,
                    nextToken: file.getNextToken(colon),
                    message: 'Illegal space after key colon'
                });
            });
        });
        file.iterateNodesByType('ObjectExpression', function(node) {
Function (anonymous_572)
✓ Was called            node.properties.forEach(function(property) {···
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return;
                }

                var keyToken = file.getFirstNodeToken(property.key);
                var colon = file.findNextToken(keyToken, 'Punctuator', ':');

                errors.assert.noWhitespaceBetween({
                    token: colon,
                    nextToken: file.getNextToken(colon),
                    message: 'Illegal space after key colon'
                });
            });
            node.properties.forEach(function(property) {
Branch IfStatement
✓ Positive was executed (if)                if (property.shorthand || property.method || property.kind !== 'init') {···
                    return;
                }
✓ Negative was executed (else)                }···

                var keyToken = file.getFirstNodeToken(property.key);
Branch LogicalExpression
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
Branch LogicalExpression
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return;
                }
                var keyToken = file.getFirstNodeToken(property.key);
                var colon = file.findNextToken(keyToken, 'Punctuator', ':');
                errors.assert.noWhitespaceBetween({
                    token: colon,
                    nextToken: file.getNextToken(colon),
                    message: 'Illegal space after key colon'
                });
            });
        });
    }
};

disallow-quoted-keys-in-objects.js
/**
 * Disallows quoted keys in object if possible.
 *
 * Types: `String` or `Boolean`
 *
 * Values:
 *
 *  - `true` for strict mode
 *  - `"allButReserved"` allows ES3+ reserved words to remain quoted which is helpful
 *    when using this option with JSHint's `es3` flag.
 *
 * #### Example
 *
 * ```js
 * "disallowQuotedKeysInObjects": true
 * ```
 *
 * ##### Valid for mode `true`
 *
 * ```js
 * var x = { a: { default: 1 } };
 * ```
 *
 * ##### Valid for mode `"allButReserved"`
 *
 * ```js
 * var x = {a: 1, 'default': 2};
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = {'a': 1};
 * ```
 */
var assert = require('assert');
var utils = require('../utils');
Function (anonymous_573)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_574)
✓ Was called    configure: function(options) {···
        assert(
            options === true || options === 'allButReserved',
            this.getOptionName() + ' option requires a true value or "allButReserved"'
        );

        this._mode = options;
    },
    configure: function(options) {
        assert(
Branch LogicalExpression
✓ Was returned            options === true || options === 'allButReserved',
✓ Was returned            options === true || options === 'allButReserved',
            options === true || options === 'allButReserved',
            this.getOptionName() + ' option requires a true value or "allButReserved"'
        );
        this._mode = options;
    },
Function (anonymous_575)
✓ Was called    getOptionName: function() {···
        return 'disallowQuotedKeysInObjects';
    },
    getOptionName: function() {
        return 'disallowQuotedKeysInObjects';
    },
Function (anonymous_576)
✓ Was called    check: function(file, errors) {···
        var KEY_NAME_RE = /^(0|[1-9][0-9]*|[a-zA-Z_$]+[\w$]*)$/; // number or identifier
        var mode = this._mode;

        file.iterateNodesByType('ObjectExpression', function(node) {
            node.properties.forEach(function(prop) {
                var key = prop.key;
                if (key.type === 'Literal' &&
                    typeof key.value === 'string' &&
                    KEY_NAME_RE.test(key.value)
                ) {
                    if (mode === 'allButReserved' &&
                        (utils.isEs3Keyword(key.value) || utils.isEs3FutureReservedWord(key.value))
                    ) {
                        return;
                    }
                    errors.add('Extra quotes for key', prop.loc.start);
                }
            });
        });
    }
    check: function(file, errors) {
        var KEY_NAME_RE = /^(0|[1-9][0-9]*|[a-zA-Z_$]+[\w$]*)$/; // number or identifier
        var mode = this._mode;
Function (anonymous_577)
✓ Was called        file.iterateNodesByType('ObjectExpression', function(node) {···
            node.properties.forEach(function(prop) {
                var key = prop.key;
                if (key.type === 'Literal' &&
                    typeof key.value === 'string' &&
                    KEY_NAME_RE.test(key.value)
                ) {
                    if (mode === 'allButReserved' &&
                        (utils.isEs3Keyword(key.value) || utils.isEs3FutureReservedWord(key.value))
                    ) {
                        return;
                    }
                    errors.add('Extra quotes for key', prop.loc.start);
                }
            });
        });
        file.iterateNodesByType('ObjectExpression', function(node) {
Function (anonymous_578)
✓ Was called            node.properties.forEach(function(prop) {···
                var key = prop.key;
                if (key.type === 'Literal' &&
                    typeof key.value === 'string' &&
                    KEY_NAME_RE.test(key.value)
                ) {
                    if (mode === 'allButReserved' &&
                        (utils.isEs3Keyword(key.value) || utils.isEs3FutureReservedWord(key.value))
                    ) {
                        return;
                    }
                    errors.add('Extra quotes for key', prop.loc.start);
                }
            });
            node.properties.forEach(function(prop) {
                var key = prop.key;
Branch IfStatement
✓ Positive was executed (if)                ) {···
                    if (mode === 'allButReserved' &&
                        (utils.isEs3Keyword(key.value) || utils.isEs3FutureReservedWord(key.value))
                    ) {
                        return;
                    }
                    errors.add('Extra quotes for key', prop.loc.start);
                }
✓ Negative was executed (else)                }···
            });
Branch LogicalExpression
✓ Was returned                    KEY_NAME_RE.test(key.value)
✓ Was returned                if (key.type === 'Literal' &&···
                    typeof key.value === 'string' &&
Branch LogicalExpression
✓ Was returned                    typeof key.value === 'string' &&
✓ Was returned                if (key.type === 'Literal' &&
                if (key.type === 'Literal' &&
                    typeof key.value === 'string' &&
                    KEY_NAME_RE.test(key.value)
                ) {
Branch IfStatement
✓ Positive was executed (if)                    ) {···
                        return;
                    }
✓ Negative was executed (else)                    }···
                    errors.add('Extra quotes for key', prop.loc.start);
Branch LogicalExpression
✓ Was returned                        (utils.isEs3Keyword(key.value) || utils.isEs3FutureReservedWord(key.value))
✓ Was returned                    if (mode === 'allButReserved' &&
                    if (mode === 'allButReserved' &&
Branch LogicalExpression
✓ Was returned                        (utils.isEs3Keyword(key.value) || utils.isEs3FutureReservedWord(key.value))
✓ Was returned                        (utils.isEs3Keyword(key.value) || utils.isEs3FutureReservedWord(key.value))
                        (utils.isEs3Keyword(key.value) || utils.isEs3FutureReservedWord(key.value))
                    ) {
                        return;
                    }
                    errors.add('Extra quotes for key', prop.loc.start);
                }
            });
        });
    }
};

require-quoted-keys-in-objects.js
/**
 * Requires quoted keys in objects.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "requireQuotedKeysInObjects": true
 * ```
 *
 * ##### Valid
 *
 * ```js
  * var x = { 'a': { "default": 1 } };
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = { a: 1 };
 * ```
 */
var assert = require('assert');
Function (anonymous_579)
✓ Was calledmodule.exports = function() { };
module.exports = function() { };
module.exports.prototype = {
Function (anonymous_580)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_581)
✓ Was called    getOptionName: function() {···
        return 'requireQuotedKeysInObjects';
    },
    getOptionName: function() {
        return 'requireQuotedKeysInObjects';
    },
Function (anonymous_582)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('ObjectExpression', function(node) {
            node.properties.forEach(function(prop) {
                if (prop.shorthand || prop.method || prop.kind !== 'init') {
                    return;
                }

                var key = prop.key;
                if (!(typeof key.value === 'string' && key.type === 'Literal')) {
                    errors.add('Object key without surrounding quotes', prop.loc.start);
                }
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_583)
✓ Was called        file.iterateNodesByType('ObjectExpression', function(node) {···
            node.properties.forEach(function(prop) {
                if (prop.shorthand || prop.method || prop.kind !== 'init') {
                    return;
                }

                var key = prop.key;
                if (!(typeof key.value === 'string' && key.type === 'Literal')) {
                    errors.add('Object key without surrounding quotes', prop.loc.start);
                }
            });
        });
        file.iterateNodesByType('ObjectExpression', function(node) {
Function (anonymous_584)
✓ Was called            node.properties.forEach(function(prop) {···
                if (prop.shorthand || prop.method || prop.kind !== 'init') {
                    return;
                }

                var key = prop.key;
                if (!(typeof key.value === 'string' && key.type === 'Literal')) {
                    errors.add('Object key without surrounding quotes', prop.loc.start);
                }
            });
            node.properties.forEach(function(prop) {
Branch IfStatement
✓ Positive was executed (if)                if (prop.shorthand || prop.method || prop.kind !== 'init') {···
                    return;
                }
✓ Negative was executed (else)                }···

                var key = prop.key;
Branch LogicalExpression
✓ Was returned                if (prop.shorthand || prop.method || prop.kind !== 'init') {
✓ Was returned                if (prop.shorthand || prop.method || prop.kind !== 'init') {
Branch LogicalExpression
✓ Was returned                if (prop.shorthand || prop.method || prop.kind !== 'init') {
✓ Was returned                if (prop.shorthand || prop.method || prop.kind !== 'init') {
                if (prop.shorthand || prop.method || prop.kind !== 'init') {
                    return;
                }
                var key = prop.key;
Branch IfStatement
✓ Positive was executed (if)                if (!(typeof key.value === 'string' && key.type === 'Literal')) {···
                    errors.add('Object key without surrounding quotes', prop.loc.start);
                }
✓ Negative was executed (else)                }···
            });
Branch LogicalExpression
✓ Was returned                if (!(typeof key.value === 'string' && key.type === 'Literal')) {
✓ Was returned                if (!(typeof key.value === 'string' && key.type === 'Literal')) {
                if (!(typeof key.value === 'string' && key.type === 'Literal')) {
                    errors.add('Object key without surrounding quotes', prop.loc.start);
                }
            });
        });
    }
};

disallow-dangling-underscores.js
/**
 * Disallows identifiers that start or end in `_`. Some popular identifiers are automatically listed as exceptions:
 *
 *  - `__proto__` (javascript)
 *  - `_` (underscore.js)
 *  - `__filename` (node.js global)
 *  - `__dirname` (node.js global)
 *  - `super_` (node.js, used by
 *    [`util.inherits`](http://nodejs.org/docs/latest/api/util.html#util_util_inherits_constructor_superconstructor))
 *
 * Types: `Boolean` or `Object`
 *
 * Values:
 *  - `true`
 *  - `Object`:
 *     - `allExcept`: array of quoted identifiers
 *
 * JSHint: [`nomen`](http://www.jshint.com/docs/options/#nomen)
 *
 * #### Example
 *
 * ```js
 * "disallowDanglingUnderscores": { "allExcept": ["_exception"] }
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var x = 1;
 * var o = obj.__proto__;
 * var y = _.extend;
 * var z = __dirname;
 * var w = __filename;
 * var x_y = 1;
 * var v = _exception;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var _x = 1;
 * var x_ = 1;
 * var x_y_ = 1;
 * ```
 */
var assert = require('assert');
Function (anonymous_585)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_586)
✓ Was called    configure: function(identifiers) {···
        assert(
            identifiers === true ||
            typeof identifiers === 'object',
            this.getOptionName() + ' option requires the value `true` ' +
            'or an object with String[] `allExcept` property'
        );

        // verify first item in `allExcept` property in object (if it's an object)
        assert(
            typeof identifiers !== 'object' ||
            Array.isArray(identifiers.allExcept) &&
            typeof identifiers.allExcept[0] === 'string',
            'Property `allExcept` in ' + this.getOptionName() + ' should be an array of strings'
        );

        var isTrue = identifiers === true;
        var defaultIdentifiers = [
            '__proto__',
            '_',
            '__dirname',
            '__filename',
            'super_'
        ];

        if (isTrue) {
            identifiers = defaultIdentifiers;
        } else {
            identifiers = (identifiers.allExcept).concat(defaultIdentifiers);
        }

        this._identifierIndex = {};
        for (var i = 0, l = identifiers.length; i < l; i++) {
            this._identifierIndex[identifiers[i]] = true;
        }
    },
    configure: function(identifiers) {
        assert(
Branch LogicalExpression
✓ Was returned            typeof identifiers === 'object',
✓ Was returned            identifiers === true ||
            identifiers === true ||
            typeof identifiers === 'object',
            this.getOptionName() + ' option requires the value `true` ' +
            'or an object with String[] `allExcept` property'
        );
        // verify first item in `allExcept` property in object (if it's an object)
        assert(
Branch LogicalExpression
✓ Was returned            Array.isArray(identifiers.allExcept) &&···
            typeof identifiers.allExcept[0] === 'string',
✓ Was returned            typeof identifiers !== 'object' ||
            typeof identifiers !== 'object' ||
Branch LogicalExpression
✓ Was returned            typeof identifiers.allExcept[0] === 'string',
✓ Was returned            Array.isArray(identifiers.allExcept) &&
            Array.isArray(identifiers.allExcept) &&
            typeof identifiers.allExcept[0] === 'string',
            'Property `allExcept` in ' + this.getOptionName() + ' should be an array of strings'
        );
        var isTrue = identifiers === true;
        var defaultIdentifiers = [
            '__proto__',
            '_',
            '__dirname',
            '__filename',
            'super_'
        ];
Branch IfStatement
✓ Positive was executed (if)        if (isTrue) {···
            identifiers = defaultIdentifiers;
        } else {
✓ Negative was executed (else)        } else {···
            identifiers = (identifiers.allExcept).concat(defaultIdentifiers);
        }
        if (isTrue) {
            identifiers = defaultIdentifiers;
        } else {
            identifiers = (identifiers.allExcept).concat(defaultIdentifiers);
        }
        this._identifierIndex = {};
        for (var i = 0, l = identifiers.length; i < l; i++) {
            this._identifierIndex[identifiers[i]] = true;
        }
    },
Function (anonymous_587)
✓ Was called    getOptionName: function() {···
        return 'disallowDanglingUnderscores';
    },
    getOptionName: function() {
        return 'disallowDanglingUnderscores';
    },
Function (anonymous_588)
✓ Was called    check: function(file, errors) {···
        var allowedIdentifiers = this._identifierIndex;

        file.iterateTokensByType('Identifier', function(token) {
            var value = token.value;
            if ((value[0] === '_' || value.slice(-1) === '_') &&
                !allowedIdentifiers[value]
            ) {
                errors.add(
                    'Invalid dangling underscore found',
                    token.loc.start.line,
                    token.loc.start.column
                );
            }
        });
    }
    check: function(file, errors) {
        var allowedIdentifiers = this._identifierIndex;
Function (anonymous_589)
✓ Was called        file.iterateTokensByType('Identifier', function(token) {···
            var value = token.value;
            if ((value[0] === '_' || value.slice(-1) === '_') &&
                !allowedIdentifiers[value]
            ) {
                errors.add(
                    'Invalid dangling underscore found',
                    token.loc.start.line,
                    token.loc.start.column
                );
            }
        });
        file.iterateTokensByType('Identifier', function(token) {
            var value = token.value;
Branch IfStatement
✓ Positive was executed (if)            ) {···
                errors.add(
                    'Invalid dangling underscore found',
                    token.loc.start.line,
                    token.loc.start.column
                );
            }
✓ Negative was executed (else)            }···
        });
Branch LogicalExpression
✓ Was returned                !allowedIdentifiers[value]
✓ Was returned            if ((value[0] === '_' || value.slice(-1) === '_') &&
Branch LogicalExpression
✓ Was returned            if ((value[0] === '_' || value.slice(-1) === '_') &&
✓ Was returned            if ((value[0] === '_' || value.slice(-1) === '_') &&
            if ((value[0] === '_' || value.slice(-1) === '_') &&
                !allowedIdentifiers[value]
            ) {
                errors.add(
                    'Invalid dangling underscore found',
                    token.loc.start.line,
                    token.loc.start.column
                );
            }
        });
    }
};

require-aligned-object-values.js
/**
 * Requires proper alignment in object literals.
 *
 * Type: `String`
 *
 * Values:
 *  - `"all"` for strict mode,
 *  - `"ignoreFunction"` ignores objects if one of the property values is a function expression,
 *  - `"ignoreLineBreak"` ignores objects if there are line breaks between properties
 *
 * #### Example
 *
 * ```js
 * "requireAlignedObjectValues": "all"
 * ```
 *
 * ##### Valid
 * ```js
 * var x = {
 *     a   : 1,
 *     bcd : 2,
 *     ef  : 'str'
 * };
 * ```
 * ##### Invalid
 * ```js
 * var x = {
 *     a : 1,
 *     bcd : 2,
 *     ef : 'str'
 * };
 * ```
 */
var assert = require('assert');
Function (anonymous_590)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_591)
✓ Was called    configure: function(mode) {···
        var modes = {
            'all': 'all',
            'ignoreFunction': 'ignoreFunction',
            'ignoreLineBreak': 'ignoreLineBreak',
            'skipWithFunction': 'ignoreFunction',
            'skipWithLineBreak': 'ignoreLineBreak'
        };
        assert(
            typeof mode === 'string' && modes[mode],
            this.getOptionName() + ' requires one of the following values: ' + Object.keys(modes).join(', ')
        );
        this._mode = modes[mode];
    },
    configure: function(mode) {
        var modes = {
            'all': 'all',
            'ignoreFunction': 'ignoreFunction',
            'ignoreLineBreak': 'ignoreLineBreak',
            'skipWithFunction': 'ignoreFunction',
            'skipWithLineBreak': 'ignoreLineBreak'
        };
        assert(
Branch LogicalExpression
✓ Was returned            typeof mode === 'string' && modes[mode],
✗ Was not returned            typeof mode === 'string' && modes[mode],
            typeof mode === 'string' && modes[mode],
            this.getOptionName() + ' requires one of the following values: ' + Object.keys(modes).join(', ')
        );
        this._mode = modes[mode];
    },
Function (anonymous_592)
✓ Was called    getOptionName: function() {···
        return 'requireAlignedObjectValues';
    },
    getOptionName: function() {
        return 'requireAlignedObjectValues';
    },
Function (anonymous_593)
✓ Was called    check: function(file, errors) {···
        var mode = this._mode;

        file.iterateNodesByType('ObjectExpression', function(node) {
            if (node.loc.start.line === node.loc.end.line || node.properties < 2) {
                return;
            }

            var maxKeyEndPos = 0;
            var skip = node.properties.some(function(property, index) {
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return true;
                }

                maxKeyEndPos = Math.max(maxKeyEndPos, property.key.loc.end.column);

                if (mode === 'ignoreFunction' && property.value.type === 'FunctionExpression') {
                    return true;
                }

                if (mode === 'ignoreLineBreak' && index > 0 &&
                     node.properties[index - 1].loc.end.line !== property.loc.start.line - 1) {
                    return true;
                }
            });

            if (skip) {
                return;
            }

            node.properties.forEach(function(property) {
                var keyToken = file.getFirstNodeToken(property.key);
                var colon = file.getNextToken(keyToken);
                errors.assert.spacesBetween({
                    token: keyToken,
                    nextToken: colon,
                    exactly: maxKeyEndPos - keyToken.loc.end.column + 1,
                    message: 'Alignment required'
                });
            });
        });
    }
    check: function(file, errors) {
        var mode = this._mode;
Function (anonymous_594)
✓ Was called        file.iterateNodesByType('ObjectExpression', function(node) {···
            if (node.loc.start.line === node.loc.end.line || node.properties < 2) {
                return;
            }

            var maxKeyEndPos = 0;
            var skip = node.properties.some(function(property, index) {
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return true;
                }

                maxKeyEndPos = Math.max(maxKeyEndPos, property.key.loc.end.column);

                if (mode === 'ignoreFunction' && property.value.type === 'FunctionExpression') {
                    return true;
                }

                if (mode === 'ignoreLineBreak' && index > 0 &&
                     node.properties[index - 1].loc.end.line !== property.loc.start.line - 1) {
                    return true;
                }
            });

            if (skip) {
                return;
            }

            node.properties.forEach(function(property) {
                var keyToken = file.getFirstNodeToken(property.key);
                var colon = file.getNextToken(keyToken);
                errors.assert.spacesBetween({
                    token: keyToken,
                    nextToken: colon,
                    exactly: maxKeyEndPos - keyToken.loc.end.column + 1,
                    message: 'Alignment required'
                });
            });
        });
        file.iterateNodesByType('ObjectExpression', function(node) {
Branch IfStatement
✓ Positive was executed (if)            if (node.loc.start.line === node.loc.end.line || node.properties < 2) {···
                return;
            }
✓ Negative was executed (else)            }···

            var maxKeyEndPos = 0;
Branch LogicalExpression
✓ Was returned            if (node.loc.start.line === node.loc.end.line || node.properties < 2) {
✓ Was returned            if (node.loc.start.line === node.loc.end.line || node.properties < 2) {
            if (node.loc.start.line === node.loc.end.line || node.properties < 2) {
                return;
            }
            var maxKeyEndPos = 0;
Function (anonymous_595)
✓ Was called            var skip = node.properties.some(function(property, index) {···
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return true;
                }

                maxKeyEndPos = Math.max(maxKeyEndPos, property.key.loc.end.column);

                if (mode === 'ignoreFunction' && property.value.type === 'FunctionExpression') {
                    return true;
                }

                if (mode === 'ignoreLineBreak' && index > 0 &&
                     node.properties[index - 1].loc.end.line !== property.loc.start.line - 1) {
                    return true;
                }
            });
            var skip = node.properties.some(function(property, index) {
Branch IfStatement
✓ Positive was executed (if)                if (property.shorthand || property.method || property.kind !== 'init') {···
                    return true;
                }
✓ Negative was executed (else)                }···

                maxKeyEndPos = Math.max(maxKeyEndPos, property.key.loc.end.column);
Branch LogicalExpression
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
Branch LogicalExpression
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
✓ Was returned                if (property.shorthand || property.method || property.kind !== 'init') {
                if (property.shorthand || property.method || property.kind !== 'init') {
                    return true;
                }
                maxKeyEndPos = Math.max(maxKeyEndPos, property.key.loc.end.column);
Branch IfStatement
✓ Positive was executed (if)                if (mode === 'ignoreFunction' && property.value.type === 'FunctionExpression') {···
                    return true;
                }
✓ Negative was executed (else)                }···

                if (mode === 'ignoreLineBreak' && index > 0 &&
Branch LogicalExpression
✓ Was returned                if (mode === 'ignoreFunction' && property.value.type === 'FunctionExpression') {
✓ Was returned                if (mode === 'ignoreFunction' && property.value.type === 'FunctionExpression') {
                if (mode === 'ignoreFunction' && property.value.type === 'FunctionExpression') {
                    return true;
                }
Branch IfStatement
✓ Positive was executed (if)                     node.properties[index - 1].loc.end.line !== property.loc.start.line - 1) {···
                    return true;
                }
✓ Negative was executed (else)                }···
            });
Branch LogicalExpression
✓ Was returned                     node.properties[index - 1].loc.end.line !== property.loc.start.line - 1) {
✓ Was returned                if (mode === 'ignoreLineBreak' && index > 0 &&
Branch LogicalExpression
✓ Was returned                if (mode === 'ignoreLineBreak' && index > 0 &&
✓ Was returned                if (mode === 'ignoreLineBreak' && index > 0 &&
                if (mode === 'ignoreLineBreak' && index > 0 &&
                     node.properties[index - 1].loc.end.line !== property.loc.start.line - 1) {
                    return true;
                }
            });
Branch IfStatement
✓ Positive was executed (if)            if (skip) {···
                return;
            }
✓ Negative was executed (else)            }···

            node.properties.forEach(function(property) {
            if (skip) {
                return;
            }
Function (anonymous_596)
✓ Was called            node.properties.forEach(function(property) {···
                var keyToken = file.getFirstNodeToken(property.key);
                var colon = file.getNextToken(keyToken);
                errors.assert.spacesBetween({
                    token: keyToken,
                    nextToken: colon,
                    exactly: maxKeyEndPos - keyToken.loc.end.column + 1,
                    message: 'Alignment required'
                });
            });
            node.properties.forEach(function(property) {
                var keyToken = file.getFirstNodeToken(property.key);
                var colon = file.getNextToken(keyToken);
                errors.assert.spacesBetween({
                    token: keyToken,
                    nextToken: colon,
                    exactly: maxKeyEndPos - keyToken.loc.end.column + 1,
                    message: 'Alignment required'
                });
            });
        });
    }
};

validate-aligned-function-parameters.js
/**
 * Validates proper alignment of function parameters.
 *
 * Type: `Object` or `Boolean`
 *
 * Values: `"lineBreakAfterOpeningBraces"`, `"lineBreakBeforeClosingBraces"` as child properties or `true`.
 *
 * #### Example
 *
 * ```js
 * "validateAlignedFunctionParameters": {
 *   "lineBreakAfterOpeningBraces": true,
 *   "lineBreakBeforeClosingBraces": true
 * }
 * ```
 *
 * ##### Valid
 * ```js
 * function (
 *   thisIs,
 *   theLongestList,
 *   ofParametersEverWritten
 * ) {}
 * ```
 * ##### Invalid
 * ```js
 * function (thisIs,
 *           theLongestList,
 *           ofParametersEverWritten) {}
 * ```
 */
var assert = require('assert');
Function (anonymous_597)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_598)
✓ Was called    configure: function(options) {···
        var validProperties = [
            'lineBreakAfterOpeningBrace',
            'lineBreakBeforeClosingBrace'
        ];
        var optionName = this.getOptionName();

        assert(
            typeof options === 'object' || options === true,
            optionName + ' option must be an object or boolean true'
        );

        if (typeof options === 'object') {
            validProperties.forEach(function(key) {
                var isPresent = key in options;

                if (isPresent) {
                    assert(
                        options[key] === true,
                        optionName + '.' + key + ' property requires true value or should be removed'
                    );
                }
            });

            validProperties.forEach(function(property) {
                this['_' + property] = Boolean(options[property]);
            }.bind(this));
        }
    },
    configure: function(options) {
        var validProperties = [
            'lineBreakAfterOpeningBrace',
            'lineBreakBeforeClosingBrace'
        ];
        var optionName = this.getOptionName();
        assert(
Branch LogicalExpression
✓ Was returned            typeof options === 'object' || options === true,
✓ Was returned            typeof options === 'object' || options === true,
            typeof options === 'object' || options === true,
            optionName + ' option must be an object or boolean true'
        );
Branch IfStatement
✓ Positive was executed (if)        if (typeof options === 'object') {···
            validProperties.forEach(function(key) {
                var isPresent = key in options;

                if (isPresent) {
                    assert(
                        options[key] === true,
                        optionName + '.' + key + ' property requires true value or should be removed'
                    );
                }
            });

            validProperties.forEach(function(property) {
                this['_' + property] = Boolean(options[property]);
            }.bind(this));
        }
✓ Negative was executed (else)        }···
    },
        if (typeof options === 'object') {
Function (anonymous_599)
✓ Was called            validProperties.forEach(function(key) {···
                var isPresent = key in options;

                if (isPresent) {
                    assert(
                        options[key] === true,
                        optionName + '.' + key + ' property requires true value or should be removed'
                    );
                }
            });
            validProperties.forEach(function(key) {
                var isPresent = key in options;
Branch IfStatement
✓ Positive was executed (if)                if (isPresent) {···
                    assert(
                        options[key] === true,
                        optionName + '.' + key + ' property requires true value or should be removed'
                    );
                }
✓ Negative was executed (else)                }···
            });
                if (isPresent) {
                    assert(
                        options[key] === true,
                        optionName + '.' + key + ' property requires true value or should be removed'
                    );
                }
            });
Function (anonymous_600)
✓ Was called            validProperties.forEach(function(property) {···
                this['_' + property] = Boolean(options[property]);
            }.bind(this));
            validProperties.forEach(function(property) {
                this['_' + property] = Boolean(options[property]);
            }.bind(this));
        }
    },
Function (anonymous_601)
✓ Was called    getOptionName: function() {···
        return 'validateAlignedFunctionParameters';
    },
    getOptionName: function() {
        return 'validateAlignedFunctionParameters';
    },
Function (anonymous_602)
✓ Was called    check: function(file, errors) {···
        var lineBreakAfterOpeningBrace = this._lineBreakAfterOpeningBrace;
        var lineBreakBeforeClosingBrace = this._lineBreakBeforeClosingBrace;

        file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {

            // ignore this rule if there are no parameters
            if (!(node.params && node.params.length > 0)) {
                return;
            }

            // ignore this rule if the parameters are not multi-line
            var firstParameter = file.getFirstNodeToken(node.params[0]);
            var lastParameter = node.params[node.params.length - 1];
            if (firstParameter.loc.start.line === lastParameter.loc.end.line) {
                return;
            }

            // look for the furthest parameter start position
            var maxParamStartPos = 0;
            node.params.forEach(function(parameter) {
                maxParamStartPos = Math.max(maxParamStartPos, parameter.loc.start.column);
            });

            // make sure all parameters are lined up
            node.params.forEach(function(parameter) {
                if (parameter.loc.start.column !== maxParamStartPos) {
                    errors.add('Multi-line parameters are not aligned.', parameter.loc.start);
                }
            });

            // make sure the first parameter is on a new line
            if (lineBreakAfterOpeningBrace) {
                var openingBrace = file.getPrevToken(firstParameter);
                errors.assert.differentLine({
                    token: openingBrace,
                    nextToken: firstParameter,
                    message: 'There is no line break after the opening brace'
                });
            }

            // make sure the closing brace is on a new line
            if (lineBreakBeforeClosingBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                var closingBrace = file.getPrevToken(bodyToken);
                errors.assert.differentLine({
                    token: lastParameter,
                    nextToken: closingBrace,
                    message: 'There is no line break before the closing brace'
                });
            }

        });
    }
    check: function(file, errors) {
        var lineBreakAfterOpeningBrace = this._lineBreakAfterOpeningBrace;
        var lineBreakBeforeClosingBrace = this._lineBreakBeforeClosingBrace;
Function (anonymous_603)
✓ Was called        file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {···

            // ignore this rule if there are no parameters
            if (!(node.params && node.params.length > 0)) {
                return;
            }

            // ignore this rule if the parameters are not multi-line
            var firstParameter = file.getFirstNodeToken(node.params[0]);
            var lastParameter = node.params[node.params.length - 1];
            if (firstParameter.loc.start.line === lastParameter.loc.end.line) {
                return;
            }

            // look for the furthest parameter start position
            var maxParamStartPos = 0;
            node.params.forEach(function(parameter) {
                maxParamStartPos = Math.max(maxParamStartPos, parameter.loc.start.column);
            });

            // make sure all parameters are lined up
            node.params.forEach(function(parameter) {
                if (parameter.loc.start.column !== maxParamStartPos) {
                    errors.add('Multi-line parameters are not aligned.', parameter.loc.start);
                }
            });

            // make sure the first parameter is on a new line
            if (lineBreakAfterOpeningBrace) {
                var openingBrace = file.getPrevToken(firstParameter);
                errors.assert.differentLine({
                    token: openingBrace,
                    nextToken: firstParameter,
                    message: 'There is no line break after the opening brace'
                });
            }

            // make sure the closing brace is on a new line
            if (lineBreakBeforeClosingBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                var closingBrace = file.getPrevToken(bodyToken);
                errors.assert.differentLine({
                    token: lastParameter,
                    nextToken: closingBrace,
                    message: 'There is no line break before the closing brace'
                });
            }

        });
        file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {
            // ignore this rule if there are no parameters
Branch IfStatement
✗ Positive was not executed (if)            if (!(node.params && node.params.length > 0)) {···
                return;
            }
✓ Negative was executed (else)            }···

            // ignore this rule if the parameters are not multi-line
Branch LogicalExpression
✓ Was returned            if (!(node.params && node.params.length > 0)) {
✗ Was not returned            if (!(node.params && node.params.length > 0)) {
            if (!(node.params && node.params.length > 0)) {
                return;
            }
            // ignore this rule if the parameters are not multi-line
            var firstParameter = file.getFirstNodeToken(node.params[0]);
            var lastParameter = node.params[node.params.length - 1];
Branch IfStatement
✓ Positive was executed (if)            if (firstParameter.loc.start.line === lastParameter.loc.end.line) {···
                return;
            }
✓ Negative was executed (else)            }···

            // look for the furthest parameter start position
            if (firstParameter.loc.start.line === lastParameter.loc.end.line) {
                return;
            }
            // look for the furthest parameter start position
            var maxParamStartPos = 0;
Function (anonymous_604)
✓ Was called            node.params.forEach(function(parameter) {···
                maxParamStartPos = Math.max(maxParamStartPos, parameter.loc.start.column);
            });
            node.params.forEach(function(parameter) {
                maxParamStartPos = Math.max(maxParamStartPos, parameter.loc.start.column);
            });
            // make sure all parameters are lined up
Function (anonymous_605)
✓ Was called            node.params.forEach(function(parameter) {···
                if (parameter.loc.start.column !== maxParamStartPos) {
                    errors.add('Multi-line parameters are not aligned.', parameter.loc.start);
                }
            });
            node.params.forEach(function(parameter) {
Branch IfStatement
✓ Positive was executed (if)                if (parameter.loc.start.column !== maxParamStartPos) {···
                    errors.add('Multi-line parameters are not aligned.', parameter.loc.start);
                }
✓ Negative was executed (else)                }···
            });
                if (parameter.loc.start.column !== maxParamStartPos) {
                    errors.add('Multi-line parameters are not aligned.', parameter.loc.start);
                }
            });
            // make sure the first parameter is on a new line
Branch IfStatement
✓ Positive was executed (if)            if (lineBreakAfterOpeningBrace) {···
                var openingBrace = file.getPrevToken(firstParameter);
                errors.assert.differentLine({
                    token: openingBrace,
                    nextToken: firstParameter,
                    message: 'There is no line break after the opening brace'
                });
            }
✓ Negative was executed (else)            }···

            // make sure the closing brace is on a new line
            if (lineBreakAfterOpeningBrace) {
                var openingBrace = file.getPrevToken(firstParameter);
                errors.assert.differentLine({
                    token: openingBrace,
                    nextToken: firstParameter,
                    message: 'There is no line break after the opening brace'
                });
            }
            // make sure the closing brace is on a new line
Branch IfStatement
✓ Positive was executed (if)            if (lineBreakBeforeClosingBrace) {···
                var bodyToken = file.getFirstNodeToken(node.body);
                var closingBrace = file.getPrevToken(bodyToken);
                errors.assert.differentLine({
                    token: lastParameter,
                    nextToken: closingBrace,
                    message: 'There is no line break before the closing brace'
                });
            }
✓ Negative was executed (else)            }···

        });
            if (lineBreakBeforeClosingBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                var closingBrace = file.getPrevToken(bodyToken);
                errors.assert.differentLine({
                    token: lastParameter,
                    nextToken: closingBrace,
                    message: 'There is no line break before the closing brace'
                });
            }
        });
    }
};

disallow-padding-newlines-after-blocks.js
/**
 * Disallow a newline after blocks
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowPaddingNewLinesAfterBlocks": true
 * ```
 *
 * ##### Valid
 *
 * ```js
  * function () {
 *     for (var i = 0; i < 2; i++) {
 *         if (true) {
 *             return false;
 *         }
 *         continue;
 *     }
 *     var obj = {
 *         foo: function() {
 *             return 1;
 *         },
 *         bar: function() {
 *             return 2;
 *         }
 *     };
 * }
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * function () {
 *     for (var i = 0; i < 2; i++) {
 *         if (true) {
 *             return false;
 *         }
 *
 *         continue;
 *     }
 *
 *     var obj = {
 *         foo: function() {
 *             return 1;
 *         },
 *
 *         bar: function() {
 *             return 2;
 *         }
 *     };
 * }
 * ```
 */
var assert = require('assert');
Function (anonymous_606)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_607)
✓ Was called    configure: function(value) {···
        assert(
            value === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(value) {
        assert(
            value === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_608)
✓ Was called    getOptionName: function() {···
        return 'disallowPaddingNewLinesAfterBlocks';
    },
    getOptionName: function() {
        return 'disallowPaddingNewLinesAfterBlocks';
    },
Function (anonymous_609)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('BlockStatement', function(node) {
            var closingBracket = file.getLastNodeToken(node);
            var nextToken = file.getNextToken(closingBracket);

            while (nextToken.type !== 'EOF') {
                if (closingBracket.loc.end.line === nextToken.loc.start.line) {
                    nextToken = file.getNextToken(nextToken);
                    continue;
                }

                errors.assert.linesBetween({
                    token: closingBracket,
                    nextToken: nextToken,
                    atMost: 1,
                    message: 'Extra newline after closing curly brace'
                });

                return;
            }
        });
    }
    check: function(file, errors) {
Function (anonymous_610)
✓ Was called        file.iterateNodesByType('BlockStatement', function(node) {···
            var closingBracket = file.getLastNodeToken(node);
            var nextToken = file.getNextToken(closingBracket);

            while (nextToken.type !== 'EOF') {
                if (closingBracket.loc.end.line === nextToken.loc.start.line) {
                    nextToken = file.getNextToken(nextToken);
                    continue;
                }

                errors.assert.linesBetween({
                    token: closingBracket,
                    nextToken: nextToken,
                    atMost: 1,
                    message: 'Extra newline after closing curly brace'
                });

                return;
            }
        });
        file.iterateNodesByType('BlockStatement', function(node) {
            var closingBracket = file.getLastNodeToken(node);
            var nextToken = file.getNextToken(closingBracket);
            while (nextToken.type !== 'EOF') {
Branch IfStatement
✓ Positive was executed (if)                if (closingBracket.loc.end.line === nextToken.loc.start.line) {···
                    nextToken = file.getNextToken(nextToken);
                    continue;
                }
✓ Negative was executed (else)                }···

                errors.assert.linesBetween({
                if (closingBracket.loc.end.line === nextToken.loc.start.line) {
                    nextToken = file.getNextToken(nextToken);
                    continue;
                }
                errors.assert.linesBetween({
                    token: closingBracket,
                    nextToken: nextToken,
                    atMost: 1,
                    message: 'Extra newline after closing curly brace'
                });
                return;
            }
        });
    }
};

require-padding-newlines-after-blocks.js
/**
 * Requires newline after blocks
 *
 * Type: `Boolean` or `Object`
 *
 * Values:
 * - `true`: always require a newline after blocks
 * - `Object`:
 *      - `"allExcept"`: `Array`
 *          - `"inCallExpressions"` Blocks don't need a line of padding in argument lists
 *          - `"inArrayExpressions"` Blocks don't need a line of padding in arrays
 *          - `"inProperties"` Blocks don't need a line of padding as object properties
 *
 * #### Example
 *
 * ```js
 * "requirePaddingNewLinesAfterBlocks": true
 * "requirePaddingNewLinesAfterBlocks": {
 *     "allExcept": ["inCallExpressions", "inArrayExpressions", "inProperties"]
 * }
 * ```
 *
 * ##### Valid
 *
 * ```js
 * function () {
 *     for (var i = 0; i < 2; i++) {
 *         if (true) {
 *             return false;
 *         }
 *
 *         continue;
 *     }
 *
 *     var obj = {
 *         foo: function() {
 *             return 1;
 *         },
 *
 *         bar: function() {
 *             return 2;
 *         }
 *     };
 *
 *     func(
 *          function() {
 *          }
 *
 *     );
 *
 *     var a = [
 *         function() {
 *         }
 *
 *     ]
 *
 * }
 * ```
 *
 * ##### Valid for `{ "allExcept": ["inCallExpressions"] }`
 *
 * ```js
 * func(
 *     2,
 *     3,
 *     function() {
 *     }
 * );
 * ```
 *
 * ##### Valid for `{ "allExcept": ["inArrayExpressions"] }`
 *
 * ```js
 * var foo = [
 *     2,
 *     3,
 *     function() {
 *     }
 * ];
 * ```
* ##### Valid for `{ "allExcept": ["inProperties"] }`
 *
 * ```js
 * var foo = {
 *     a: 2,
 *     b: function() {
 *     },
 *     c: 3
 * ];
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * function () {
 *     for (var i = 0; i < 2; i++) {
 *         if (true) {
 *             return false;
 *         }
 *         continue;
 *     }
 * }
 * ```
 */
var assert = require('assert');
var excludes = {
    'IfStatement': ['else'],
    'DoWhileStatement': ['while'],
    'TryStatement': ['catch', 'finally'],
    'CatchClause': ['finally'],
    'FunctionExpression': ['.'],
};
var exceptions = {
    'CallExpression': false,
    'ArrayExpression': false,
    'Property': false
};
Function isException
✓ Was calledfunction isException(parent) {···
    var grandpa = parent.parentNode;

    // Check if this block is used in call or array expression
    if (exceptions[grandpa.type]) {
        if (grandpa.arguments) {
            return grandpa.arguments.indexOf(parent) > -1;
        } else {
            return true;
        }
    }

    return false;
}
function isException(parent) {
    var grandpa = parent.parentNode;
    // Check if this block is used in call or array expression
Branch IfStatement
✓ Positive was executed (if)    if (exceptions[grandpa.type]) {···
        if (grandpa.arguments) {
            return grandpa.arguments.indexOf(parent) > -1;
        } else {
            return true;
        }
    }
✓ Negative was executed (else)    }···

    return false;
    if (exceptions[grandpa.type]) {
Branch IfStatement
✓ Positive was executed (if)        if (grandpa.arguments) {···
            return grandpa.arguments.indexOf(parent) > -1;
        } else {
✓ Negative was executed (else)        } else {···
            return true;
        }
        if (grandpa.arguments) {
            return grandpa.arguments.indexOf(parent) > -1;
        } else {
            return true;
        }
    }
    return false;
}
Function (anonymous_612)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_613)
✓ Was called    configure: function(value) {···
        var optionName = this.getOptionName();

        if (typeof value === 'object') {
            assert(Array.isArray(value.allExcept), optionName + ' option requires "allExcept" ' +
                'to be an array');
            assert(value.allExcept.length > 0, optionName + ' option requires "allExcept" ' +
                'to have at least one item or be set to `true`');

            value.allExcept.forEach(function(except) {
                if (except === 'inCallExpressions') {
                    exceptions.CallExpression = true;
                } else if (except === 'inArrayExpressions') {
                    exceptions.ArrayExpression = true;
                } else if (except === 'inProperties') {
                    exceptions.Property = true;
                } else {
                    assert(false, optionName + ' option requires "allExcept" to only have ' +
                        '"inCallExpressions" or "inArrayExpressions"');
                }
            });
        } else {
            assert(value === true,
                optionName + ' option requires true value or object'
            );
        }
    },
    configure: function(value) {
        var optionName = this.getOptionName();
Branch IfStatement
✓ Positive was executed (if)        if (typeof value === 'object') {···
            assert(Array.isArray(value.allExcept), optionName + ' option requires "allExcept" ' +
                'to be an array');
            assert(value.allExcept.length > 0, optionName + ' option requires "allExcept" ' +
                'to have at least one item or be set to `true`');

            value.allExcept.forEach(function(except) {
                if (except === 'inCallExpressions') {
                    exceptions.CallExpression = true;
                } else if (except === 'inArrayExpressions') {
                    exceptions.ArrayExpression = true;
                } else if (except === 'inProperties') {
                    exceptions.Property = true;
                } else {
                    assert(false, optionName + ' option requires "allExcept" to only have ' +
                        '"inCallExpressions" or "inArrayExpressions"');
                }
            });
        } else {
✓ Negative was executed (else)        } else {···
            assert(value === true,
                optionName + ' option requires true value or object'
            );
        }
        if (typeof value === 'object') {
            assert(Array.isArray(value.allExcept), optionName + ' option requires "allExcept" ' +
                'to be an array');
            assert(value.allExcept.length > 0, optionName + ' option requires "allExcept" ' +
                'to have at least one item or be set to `true`');
Function (anonymous_614)
✓ Was called            value.allExcept.forEach(function(except) {···
                if (except === 'inCallExpressions') {
                    exceptions.CallExpression = true;
                } else if (except === 'inArrayExpressions') {
                    exceptions.ArrayExpression = true;
                } else if (except === 'inProperties') {
                    exceptions.Property = true;
                } else {
                    assert(false, optionName + ' option requires "allExcept" to only have ' +
                        '"inCallExpressions" or "inArrayExpressions"');
                }
            });
            value.allExcept.forEach(function(except) {
Branch IfStatement
✓ Positive was executed (if)                if (except === 'inCallExpressions') {···
                    exceptions.CallExpression = true;
                } else if (except === 'inArrayExpressions') {
✓ Negative was executed (else)                } else if (except === 'inArrayExpressions') {···
                    exceptions.ArrayExpression = true;
                } else if (except === 'inProperties') {
                    exceptions.Property = true;
                } else {
                    assert(false, optionName + ' option requires "allExcept" to only have ' +
                        '"inCallExpressions" or "inArrayExpressions"');
                }
                if (except === 'inCallExpressions') {
                    exceptions.CallExpression = true;
Branch IfStatement
✓ Positive was executed (if)                } else if (except === 'inArrayExpressions') {···
                    exceptions.ArrayExpression = true;
                } else if (except === 'inProperties') {
✓ Negative was executed (else)                } else if (except === 'inProperties') {···
                    exceptions.Property = true;
                } else {
                    assert(false, optionName + ' option requires "allExcept" to only have ' +
                        '"inCallExpressions" or "inArrayExpressions"');
                }
                } else if (except === 'inArrayExpressions') {
                    exceptions.ArrayExpression = true;
Branch IfStatement
✓ Positive was executed (if)                } else if (except === 'inProperties') {···
                    exceptions.Property = true;
                } else {
✓ Negative was executed (else)                } else {···
                    assert(false, optionName + ' option requires "allExcept" to only have ' +
                        '"inCallExpressions" or "inArrayExpressions"');
                }
                } else if (except === 'inProperties') {
                    exceptions.Property = true;
                } else {
                    assert(false, optionName + ' option requires "allExcept" to only have ' +
                        '"inCallExpressions" or "inArrayExpressions"');
                }
            });
        } else {
            assert(value === true,
                optionName + ' option requires true value or object'
            );
        }
    },
Function (anonymous_615)
✓ Was called    getOptionName: function() {···
        return 'requirePaddingNewLinesAfterBlocks';
    },
    getOptionName: function() {
        return 'requirePaddingNewLinesAfterBlocks';
    },
Function (anonymous_616)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('BlockStatement', function(node) {

            var closingBracket = file.getLastNodeToken(node);
            var parentNode = node.parentNode;

            if (isException(parentNode)) {
                return;
            }

            var nextToken = file.getNextToken(closingBracket);

            while (nextToken.type !== 'EOF') {
                var excludeValues = excludes[parentNode.type];
                if (excludeValues && excludeValues.indexOf(nextToken.value) !== -1) {
                    return;
                }

                if (closingBracket.loc.end.line === nextToken.loc.start.line) {
                    nextToken = file.getNextToken(nextToken);
                    continue;
                }

                if (nextToken.type === 'Punctuator' && nextToken.value === '}') {
                    return;
                }

                errors.assert.linesBetween({
                    token: closingBracket,
                    nextToken: nextToken,
                    atLeast: 2,
                    message: 'Missing newline after block'
                });

                return;
            }
        });
    }
    check: function(file, errors) {
Function (anonymous_617)
✓ Was called        file.iterateNodesByType('BlockStatement', function(node) {···

            var closingBracket = file.getLastNodeToken(node);
            var parentNode = node.parentNode;

            if (isException(parentNode)) {
                return;
            }

            var nextToken = file.getNextToken(closingBracket);

            while (nextToken.type !== 'EOF') {
                var excludeValues = excludes[parentNode.type];
                if (excludeValues && excludeValues.indexOf(nextToken.value) !== -1) {
                    return;
                }

                if (closingBracket.loc.end.line === nextToken.loc.start.line) {
                    nextToken = file.getNextToken(nextToken);
                    continue;
                }

                if (nextToken.type === 'Punctuator' && nextToken.value === '}') {
                    return;
                }

                errors.assert.linesBetween({
                    token: closingBracket,
                    nextToken: nextToken,
                    atLeast: 2,
                    message: 'Missing newline after block'
                });

                return;
            }
        });
        file.iterateNodesByType('BlockStatement', function(node) {
            var closingBracket = file.getLastNodeToken(node);
            var parentNode = node.parentNode;
Branch IfStatement
✓ Positive was executed (if)            if (isException(parentNode)) {···
                return;
            }
✓ Negative was executed (else)            }···

            var nextToken = file.getNextToken(closingBracket);
            if (isException(parentNode)) {
                return;
            }
            var nextToken = file.getNextToken(closingBracket);
            while (nextToken.type !== 'EOF') {
                var excludeValues = excludes[parentNode.type];
Branch IfStatement
✓ Positive was executed (if)                if (excludeValues && excludeValues.indexOf(nextToken.value) !== -1) {···
                    return;
                }
✓ Negative was executed (else)                }···

                if (closingBracket.loc.end.line === nextToken.loc.start.line) {
Branch LogicalExpression
✓ Was returned                if (excludeValues && excludeValues.indexOf(nextToken.value) !== -1) {
✗ Was not returned                if (excludeValues && excludeValues.indexOf(nextToken.value) !== -1) {
                if (excludeValues && excludeValues.indexOf(nextToken.value) !== -1) {
                    return;
                }
Branch IfStatement
✓ Positive was executed (if)                if (closingBracket.loc.end.line === nextToken.loc.start.line) {···
                    nextToken = file.getNextToken(nextToken);
                    continue;
                }
✓ Negative was executed (else)                }···

                if (nextToken.type === 'Punctuator' && nextToken.value === '}') {
                if (closingBracket.loc.end.line === nextToken.loc.start.line) {
                    nextToken = file.getNextToken(nextToken);
                    continue;
                }
Branch IfStatement
✓ Positive was executed (if)                if (nextToken.type === 'Punctuator' && nextToken.value === '}') {···
                    return;
                }
✓ Negative was executed (else)                }···

                errors.assert.linesBetween({
Branch LogicalExpression
✓ Was returned                if (nextToken.type === 'Punctuator' && nextToken.value === '}') {
✓ Was returned                if (nextToken.type === 'Punctuator' && nextToken.value === '}') {
                if (nextToken.type === 'Punctuator' && nextToken.value === '}') {
                    return;
                }
                errors.assert.linesBetween({
                    token: closingBracket,
                    nextToken: nextToken,
                    atLeast: 2,
                    message: 'Missing newline after block'
                });
                return;
            }
        });
    }
};

disallow-padding-newlines-in-blocks.js
/**
 * Disallows blocks from beginning or ending with 2 newlines.
 *
 * Type: `Boolean`
 *
 * Value: `true` validates all non-empty blocks.
 *
 * #### Example
 *
 * ```js
 * "disallowPaddingNewlinesInBlocks": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * if (true) {
 *     doSomething();
 * }
 * if (true) {doSomething();}
 * var abc = function() {};
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * if (true) {
 *
 *     doSomething();
 *
 * }
 * ```
 */
var assert = require('assert');
Function (anonymous_618)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_619)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_620)
✓ Was called    getOptionName: function() {···
        return 'disallowPaddingNewlinesInBlocks';
    },
    getOptionName: function() {
        return 'disallowPaddingNewlinesInBlocks';
    },
Function (anonymous_621)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('BlockStatement', function(node) {
            var openingBracket = file.getFirstNodeToken(node);

            errors.assert.linesBetween({
                token: openingBracket,
                nextToken: file.getNextToken(openingBracket, {includeComments: true}),
                atMost: 1,
                message: 'Expected no padding newline after opening curly brace'
            });

            var closingBracket = file.getLastNodeToken(node);

            errors.assert.linesBetween({
                token: file.getPrevToken(closingBracket, {includeComments: true}),
                nextToken: closingBracket,
                atMost: 1,
                message: 'Expected no padding newline before closing curly brace'
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_622)
✓ Was called        file.iterateNodesByType('BlockStatement', function(node) {···
            var openingBracket = file.getFirstNodeToken(node);

            errors.assert.linesBetween({
                token: openingBracket,
                nextToken: file.getNextToken(openingBracket, {includeComments: true}),
                atMost: 1,
                message: 'Expected no padding newline after opening curly brace'
            });

            var closingBracket = file.getLastNodeToken(node);

            errors.assert.linesBetween({
                token: file.getPrevToken(closingBracket, {includeComments: true}),
                nextToken: closingBracket,
                atMost: 1,
                message: 'Expected no padding newline before closing curly brace'
            });
        });
        file.iterateNodesByType('BlockStatement', function(node) {
            var openingBracket = file.getFirstNodeToken(node);
            errors.assert.linesBetween({
                token: openingBracket,
                nextToken: file.getNextToken(openingBracket, {includeComments: true}),
                atMost: 1,
                message: 'Expected no padding newline after opening curly brace'
            });
            var closingBracket = file.getLastNodeToken(node);
            errors.assert.linesBetween({
                token: file.getPrevToken(closingBracket, {includeComments: true}),
                nextToken: closingBracket,
                atMost: 1,
                message: 'Expected no padding newline before closing curly brace'
            });
        });
    }
};

require-padding-newlines-in-blocks.js
/**
 * Requires blocks to begin and end with 2 newlines
 *
 * Types: `Boolean` or `Integer`
 *
 * Values: `true` validates all non-empty blocks,
 * `Integer` specifies a minimum number of statements in the block before validating.
 *
 * #### Example
 *
 * ```js
 * "requirePaddingNewlinesInBlocks": true
 * ```
 *
 * ##### Valid for mode `true`
 *
 * ```js
 * if (true) {
 *
 *     doSomething();
 *
 * }
 * var abc = function() {};
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * if (true) {doSomething();}
 * if (true) {
 *     doSomething();
 * }
 * ```
 *
 * ##### Valid for mode `1`
 *
 * ```js
 * if (true) {
 *
 *     doSomething();
 *     doSomethingElse();
 *
 * }
 * if (true) {
 *     doSomething();
 * }
 * if (true) { doSomething(); }
 * var abc = function() {};
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * if (true) { doSomething(); doSomethingElse(); }
 * if (true) {
 *     doSomething();
 *     doSomethingElse();
 * }
 * ```
 */
var assert = require('assert');
Function (anonymous_623)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_624)
✓ Was called    configure: function(options) {···
        assert(
            options === true || typeof options === 'number',
            this.getOptionName() + ' option requires the value true or an Integer'
        );

        this._minStatements = options === true ? 0 : options;
    },
    configure: function(options) {
        assert(
Branch LogicalExpression
✓ Was returned            options === true || typeof options === 'number',
✓ Was returned            options === true || typeof options === 'number',
            options === true || typeof options === 'number',
            this.getOptionName() + ' option requires the value true or an Integer'
        );
Branch ConditionalExpression
✓ Positive was returned (? ...)        this._minStatements = options === true ? 0 : options;
✓ Negative was returned (: ...)        this._minStatements = options === true ? 0 : options;
        this._minStatements = options === true ? 0 : options;
    },
Function (anonymous_625)
✓ Was called    getOptionName: function() {···
        return 'requirePaddingNewlinesInBlocks';
    },
    getOptionName: function() {
        return 'requirePaddingNewlinesInBlocks';
    },
Function (anonymous_626)
✓ Was called    check: function(file, errors) {···
        var minStatements = this._minStatements;

        file.iterateNodesByType('BlockStatement', function(node) {
            if (node.body.length <= minStatements) {
                return;
            }

            var openingBracket = file.getFirstNodeToken(node);

            errors.assert.linesBetween({
                token: openingBracket,
                nextToken: file.getNextToken(openingBracket, {includeComments: true}),
                atLeast: 2,
                message: 'Expected a padding newline after opening curly brace'
            });

            var closingBracket = file.getLastNodeToken(node);

            errors.assert.linesBetween({
                token: file.getPrevToken(closingBracket, {includeComments: true}),
                nextToken: closingBracket,
                atLeast: 2,
                message: 'Expected a padding newline before closing curly brace'
            });
        });
    }
    check: function(file, errors) {
        var minStatements = this._minStatements;
Function (anonymous_627)
✓ Was called        file.iterateNodesByType('BlockStatement', function(node) {···
            if (node.body.length <= minStatements) {
                return;
            }

            var openingBracket = file.getFirstNodeToken(node);

            errors.assert.linesBetween({
                token: openingBracket,
                nextToken: file.getNextToken(openingBracket, {includeComments: true}),
                atLeast: 2,
                message: 'Expected a padding newline after opening curly brace'
            });

            var closingBracket = file.getLastNodeToken(node);

            errors.assert.linesBetween({
                token: file.getPrevToken(closingBracket, {includeComments: true}),
                nextToken: closingBracket,
                atLeast: 2,
                message: 'Expected a padding newline before closing curly brace'
            });
        });
        file.iterateNodesByType('BlockStatement', function(node) {
Branch IfStatement
✓ Positive was executed (if)            if (node.body.length <= minStatements) {···
                return;
            }
✓ Negative was executed (else)            }···

            var openingBracket = file.getFirstNodeToken(node);
            if (node.body.length <= minStatements) {
                return;
            }
            var openingBracket = file.getFirstNodeToken(node);
            errors.assert.linesBetween({
                token: openingBracket,
                nextToken: file.getNextToken(openingBracket, {includeComments: true}),
                atLeast: 2,
                message: 'Expected a padding newline after opening curly brace'
            });
            var closingBracket = file.getLastNodeToken(node);
            errors.assert.linesBetween({
                token: file.getPrevToken(closingBracket, {includeComments: true}),
                nextToken: closingBracket,
                atLeast: 2,
                message: 'Expected a padding newline before closing curly brace'
            });
        });
    }
};

require-padding-newlines-in-objects.js
/**
 * Requires newline inside curly braces of all objects.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "requirePaddingNewLinesInObjects": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var x = {
 *     a: 1
 * };
 * foo({
 *     a: {
 *         b: 1
 *     }
 * });
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = { a: 1 };
 * foo({a:{b:1}});
 * ```
 */
var assert = require('assert');
Function (anonymous_628)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_629)
✓ Was called    configure: function(value) {···
        assert(
            value === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(value) {
        assert(
            value === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_630)
✓ Was called    getOptionName: function() {···
        return 'requirePaddingNewLinesInObjects';
    },
    getOptionName: function() {
        return 'requirePaddingNewLinesInObjects';
    },
Function (anonymous_631)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('ObjectExpression', function(node) {
            var openingBracket = file.getFirstNodeToken(node);
            var nextToken = file.getNextToken(openingBracket);

            if (nextToken.type === 'Punctuator' && nextToken.value === '}') {
                return;
            }

            errors.assert.differentLine({
                token: openingBracket,
                nextToken: nextToken,
                message: 'Missing newline after opening curly brace'
            });

            var closingBracket = file.getLastNodeToken(node);

            errors.assert.differentLine({
                token: file.getPrevToken(closingBracket),
                nextToken: closingBracket,
                message: 'Missing newline before closing curly brace'
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_632)
✓ Was called        file.iterateNodesByType('ObjectExpression', function(node) {···
            var openingBracket = file.getFirstNodeToken(node);
            var nextToken = file.getNextToken(openingBracket);

            if (nextToken.type === 'Punctuator' && nextToken.value === '}') {
                return;
            }

            errors.assert.differentLine({
                token: openingBracket,
                nextToken: nextToken,
                message: 'Missing newline after opening curly brace'
            });

            var closingBracket = file.getLastNodeToken(node);

            errors.assert.differentLine({
                token: file.getPrevToken(closingBracket),
                nextToken: closingBracket,
                message: 'Missing newline before closing curly brace'
            });
        });
        file.iterateNodesByType('ObjectExpression', function(node) {
            var openingBracket = file.getFirstNodeToken(node);
            var nextToken = file.getNextToken(openingBracket);
Branch IfStatement
✓ Positive was executed (if)            if (nextToken.type === 'Punctuator' && nextToken.value === '}') {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.assert.differentLine({
Branch LogicalExpression
✓ Was returned            if (nextToken.type === 'Punctuator' && nextToken.value === '}') {
✓ Was returned            if (nextToken.type === 'Punctuator' && nextToken.value === '}') {
            if (nextToken.type === 'Punctuator' && nextToken.value === '}') {
                return;
            }
            errors.assert.differentLine({
                token: openingBracket,
                nextToken: nextToken,
                message: 'Missing newline after opening curly brace'
            });
            var closingBracket = file.getLastNodeToken(node);
            errors.assert.differentLine({
                token: file.getPrevToken(closingBracket),
                nextToken: closingBracket,
                message: 'Missing newline before closing curly brace'
            });
        });
    }
};

disallow-padding-newlines-in-objects.js
/**
 * Disallows newline inside curly braces of all objects.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowPaddingNewLinesInObjects": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var x = { a: 1 };
 * foo({a: {b: 1}});
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = {
 *     a: 1
 * };
 * foo({
 *     a: {
 *         b: 1
 *     }
 * });
 * ```
 */
var assert = require('assert');
Function (anonymous_633)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_634)
✓ Was called    configure: function(value) {···
        assert(
            value === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(value) {
        assert(
            value === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_635)
✓ Was called    getOptionName: function() {···
        return 'disallowPaddingNewLinesInObjects';
    },
    getOptionName: function() {
        return 'disallowPaddingNewLinesInObjects';
    },
Function (anonymous_636)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('ObjectExpression', function(node) {
            var openingBracket = file.getFirstNodeToken(node);
            var nextToken = file.getNextToken(openingBracket);

            if (nextToken.type === 'Punctuator' && nextToken.value === '}') {
                return;
            }

            errors.assert.sameLine({
                token: openingBracket,
                nextToken: nextToken,
                message: 'Illegal newline after opening curly brace'
            });

            var closingBracket = file.getLastNodeToken(node);

            errors.assert.sameLine({
                token: file.getPrevToken(closingBracket),
                nextToken: closingBracket,
                message: 'Illegal newline before closing curly brace'
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_637)
✓ Was called        file.iterateNodesByType('ObjectExpression', function(node) {···
            var openingBracket = file.getFirstNodeToken(node);
            var nextToken = file.getNextToken(openingBracket);

            if (nextToken.type === 'Punctuator' && nextToken.value === '}') {
                return;
            }

            errors.assert.sameLine({
                token: openingBracket,
                nextToken: nextToken,
                message: 'Illegal newline after opening curly brace'
            });

            var closingBracket = file.getLastNodeToken(node);

            errors.assert.sameLine({
                token: file.getPrevToken(closingBracket),
                nextToken: closingBracket,
                message: 'Illegal newline before closing curly brace'
            });
        });
        file.iterateNodesByType('ObjectExpression', function(node) {
            var openingBracket = file.getFirstNodeToken(node);
            var nextToken = file.getNextToken(openingBracket);
Branch IfStatement
✓ Positive was executed (if)            if (nextToken.type === 'Punctuator' && nextToken.value === '}') {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.assert.sameLine({
Branch LogicalExpression
✓ Was returned            if (nextToken.type === 'Punctuator' && nextToken.value === '}') {
✓ Was returned            if (nextToken.type === 'Punctuator' && nextToken.value === '}') {
            if (nextToken.type === 'Punctuator' && nextToken.value === '}') {
                return;
            }
            errors.assert.sameLine({
                token: openingBracket,
                nextToken: nextToken,
                message: 'Illegal newline after opening curly brace'
            });
            var closingBracket = file.getLastNodeToken(node);
            errors.assert.sameLine({
                token: file.getPrevToken(closingBracket),
                nextToken: closingBracket,
                message: 'Illegal newline before closing curly brace'
            });
        });
    }
};

require-newline-before-block-statements.js
/**
 * Requires newline before opening curly brace of all block statements.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "requireNewlineBeforeBlockStatements": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * function good()
 * {
 *     var obj =
 *     {
 *         val: true
 *     };
 *
 *     return {
 *         data: obj
 *     };
 * }
 *
 * if (cond)
 * {
 *     foo();
 * }
 *
 * for (var e in elements)
 * {
 *     bar(e);
 * }
 *
 * while (cond)
 * {
 *     foo();
 * }
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * function bad(){
 *     var obj = {
 *         val: true
 *     };
 *
 *     return {
 *         data: obj
 *     };
 * }
 *
 * if (cond){
 *     foo();
 * }
 *
 * for (var e in elements){
 *     bar(e);
 * }
 *
 * while (cond){
 *     foo();
 * }
 * ```
 */
var assert = require('assert');
Function (anonymous_638)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_639)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_640)
✓ Was called    getOptionName: function() {···
        return 'requireNewlineBeforeBlockStatements';
    },
    getOptionName: function() {
        return 'requireNewlineBeforeBlockStatements';
    },
Function (anonymous_641)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('BlockStatement', function(node) {
            var openingBrace = file.getFirstNodeToken(node);
            var prevToken = file.getPrevToken(openingBrace);

            errors.assert.differentLine({
                token: prevToken,
                nextToken: openingBrace,
                message: 'Missing newline before curly brace for block statement'
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_642)
✓ Was called        file.iterateNodesByType('BlockStatement', function(node) {···
            var openingBrace = file.getFirstNodeToken(node);
            var prevToken = file.getPrevToken(openingBrace);

            errors.assert.differentLine({
                token: prevToken,
                nextToken: openingBrace,
                message: 'Missing newline before curly brace for block statement'
            });
        });
        file.iterateNodesByType('BlockStatement', function(node) {
            var openingBrace = file.getFirstNodeToken(node);
            var prevToken = file.getPrevToken(openingBrace);
            errors.assert.differentLine({
                token: prevToken,
                nextToken: openingBrace,
                message: 'Missing newline before curly brace for block statement'
            });
        });
    }
};

disallow-newline-before-block-statements.js
/**
 * Disallows newline before opening curly brace of all block statements.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowNewlineBeforeBlockStatements": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * function good(){
 *     var obj = {
 *         val: true
 *     };
 *
 *     return {
 *         data: obj
 *     };
 * }
 *
 * if (cond){
 *     foo();
 * }
 *
 * for (var e in elements){
 *     bar(e);
 * }
 *
 * while (cond){
 *     foo();
 * }
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * function bad()
 * {
 *     var obj =
 *     {
 *         val: true
 *     };
 *
 *     return {
 *         data: obj
 *     };
 * }
 *
 * if (cond)
 * {
 *     foo();
 * }
 *
 * for (var e in elements)
 * {
 *     bar(e);
 * }
 *
 * while (cond)
 * {
 *     foo();
 * }
 * ```
 */
var assert = require('assert');
Function (anonymous_643)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_644)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_645)
✓ Was called    getOptionName: function() {···
        return 'disallowNewlineBeforeBlockStatements';
    },
    getOptionName: function() {
        return 'disallowNewlineBeforeBlockStatements';
    },
Function (anonymous_646)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('BlockStatement', function(node) {
            var openingBrace = file.getFirstNodeToken(node);
            var prevToken = file.getPrevToken(openingBrace);

            errors.assert.sameLine({
                token: prevToken,
                nextToken: openingBrace,
                message: 'Newline before curly brace for block statement is disallowed'
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_647)
✓ Was called        file.iterateNodesByType('BlockStatement', function(node) {···
            var openingBrace = file.getFirstNodeToken(node);
            var prevToken = file.getPrevToken(openingBrace);

            errors.assert.sameLine({
                token: prevToken,
                nextToken: openingBrace,
                message: 'Newline before curly brace for block statement is disallowed'
            });
        });
        file.iterateNodesByType('BlockStatement', function(node) {
            var openingBrace = file.getFirstNodeToken(node);
            var prevToken = file.getPrevToken(openingBrace);
            errors.assert.sameLine({
                token: prevToken,
                nextToken: openingBrace,
                message: 'Newline before curly brace for block statement is disallowed'
            });
        });
    }
};

require-padding-newlines-before-keywords.js
/**
 * Requires an empty line above the specified keywords unless the keyword is the first expression in a block.
 *
 * Types: `Array` or `Boolean`
 *
 * Values: Array of quoted types or `true` to require padding new lines before all of the keywords below.
 *
 * #### Example
 *
 * ```js
 * "requirePaddingNewlinesBeforeKeywords": [
 *     "do",
 *     "for",
 *     "if",
 *     "else",
 *     "switch",
 *     "case",
 *     "try",
 *     "catch",
 *     "void",
 *     "while",
 *     "with",
 *     "return",
 *     "typeof",
 *     "function"
 * ]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * function(a) {
 *     if (!a) {
 *         return false;
 *     }
 *
 *     for (var i = 0; i < b; i++) {
 *         if (!a[i]) {
 *             return false;
 *         }
 *     }
 *
 *     return true;
 * }
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * function(a) {
 *     if (!a) {
 *         return false;
 *     }
 *     for (var i = 0; i < b; i++) {
 *         if (!a[i]) {
 *             return false;
 *         }
 *     }
 *     return true;
 * }
 * ```
 */
var assert = require('assert');
var defaultKeywords = require('../utils').spacedKeywords;
Function (anonymous_648)
✓ Was calledmodule.exports = function() { };
module.exports = function() { };
module.exports.prototype = {
Function (anonymous_649)
✓ Was called    configure: function(keywords) {···
        assert(Array.isArray(keywords) || keywords === true,
            this.getOptionName() + ' option requires array or true value');

        if (keywords === true) {
            keywords = defaultKeywords;
        }

        this._keywords = keywords;
    },
    configure: function(keywords) {
Branch LogicalExpression
✓ Was returned        assert(Array.isArray(keywords) || keywords === true,
✓ Was returned        assert(Array.isArray(keywords) || keywords === true,
        assert(Array.isArray(keywords) || keywords === true,
            this.getOptionName() + ' option requires array or true value');
Branch IfStatement
✓ Positive was executed (if)        if (keywords === true) {···
            keywords = defaultKeywords;
        }
✓ Negative was executed (else)        }···

        this._keywords = keywords;
        if (keywords === true) {
            keywords = defaultKeywords;
        }
        this._keywords = keywords;
    },
Function (anonymous_650)
✓ Was called    getOptionName: function() {···
        return 'requirePaddingNewlinesBeforeKeywords';
    },
    getOptionName: function() {
        return 'requirePaddingNewlinesBeforeKeywords';
    },
Function (anonymous_651)
✓ Was called    check: function(file, errors) {···
        var excludedTokens = [':', ',', '(', '='];

        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {
            var prevToken = file.getPrevToken(token);

            // Handle special case of 'else if' construct.
            if (token.value === 'if' && prevToken && prevToken.value === 'else') {
                return;
            // Handling for special cases.
            } else if (prevToken && excludedTokens.indexOf(prevToken.value) > -1) {
                return;
            }

            // Handle all other cases
            // The { character is there to handle the case of a matching token which happens to be the first
            //   statement in a block
            // The ) character is there to handle the case of `if (...) matchingKeyword` in which case
            //   requiring padding would break the statement
            if (prevToken && prevToken.value !== '{' && prevToken.value !== ')') {

                errors.assert.linesBetween({
                    token: prevToken,
                    nextToken: token,
                    atLeast: 2,
                    message: 'Keyword `' + token.value + '` should have an empty line above it'
                });
            }
        });
    }
    check: function(file, errors) {
        var excludedTokens = [':', ',', '(', '='];
Function (anonymous_652)
✓ Was called        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {···
            var prevToken = file.getPrevToken(token);

            // Handle special case of 'else if' construct.
            if (token.value === 'if' && prevToken && prevToken.value === 'else') {
                return;
            // Handling for special cases.
            } else if (prevToken && excludedTokens.indexOf(prevToken.value) > -1) {
                return;
            }

            // Handle all other cases
            // The { character is there to handle the case of a matching token which happens to be the first
            //   statement in a block
            // The ) character is there to handle the case of `if (...) matchingKeyword` in which case
            //   requiring padding would break the statement
            if (prevToken && prevToken.value !== '{' && prevToken.value !== ')') {

                errors.assert.linesBetween({
                    token: prevToken,
                    nextToken: token,
                    atLeast: 2,
                    message: 'Keyword `' + token.value + '` should have an empty line above it'
                });
            }
        });
        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {
            var prevToken = file.getPrevToken(token);
            // Handle special case of 'else if' construct.
Branch IfStatement
✓ Positive was executed (if)            if (token.value === 'if' && prevToken && prevToken.value === 'else') {···
                return;
            // Handling for special cases.
            } else if (prevToken && excludedTokens.indexOf(prevToken.value) > -1) {
✓ Negative was executed (else)            } else if (prevToken && excludedTokens.indexOf(prevToken.value) > -1) {···
                return;
            }
Branch LogicalExpression
✓ Was returned            if (token.value === 'if' && prevToken && prevToken.value === 'else') {
✓ Was returned            if (token.value === 'if' && prevToken && prevToken.value === 'else') {
Branch LogicalExpression
✓ Was returned            if (token.value === 'if' && prevToken && prevToken.value === 'else') {
✓ Was returned            if (token.value === 'if' && prevToken && prevToken.value === 'else') {
            if (token.value === 'if' && prevToken && prevToken.value === 'else') {
                return;
            // Handling for special cases.
Branch IfStatement
✓ Positive was executed (if)            } else if (prevToken && excludedTokens.indexOf(prevToken.value) > -1) {···
                return;
            }
✓ Negative was executed (else)            }···

            // Handle all other cases
Branch LogicalExpression
✓ Was returned            } else if (prevToken && excludedTokens.indexOf(prevToken.value) > -1) {
✓ Was returned            } else if (prevToken && excludedTokens.indexOf(prevToken.value) > -1) {
            } else if (prevToken && excludedTokens.indexOf(prevToken.value) > -1) {
                return;
            }
            // Handle all other cases
            // The { character is there to handle the case of a matching token which happens to be the first
            //   statement in a block
            // The ) character is there to handle the case of `if (...) matchingKeyword` in which case
            //   requiring padding would break the statement
Branch IfStatement
✓ Positive was executed (if)            if (prevToken && prevToken.value !== '{' && prevToken.value !== ')') {···

                errors.assert.linesBetween({
                    token: prevToken,
                    nextToken: token,
                    atLeast: 2,
                    message: 'Keyword `' + token.value + '` should have an empty line above it'
                });
            }
✓ Negative was executed (else)            }···
        });
Branch LogicalExpression
✓ Was returned            if (prevToken && prevToken.value !== '{' && prevToken.value !== ')') {
✓ Was returned            if (prevToken && prevToken.value !== '{' && prevToken.value !== ')') {
Branch LogicalExpression
✓ Was returned            if (prevToken && prevToken.value !== '{' && prevToken.value !== ')') {
✓ Was returned            if (prevToken && prevToken.value !== '{' && prevToken.value !== ')') {
            if (prevToken && prevToken.value !== '{' && prevToken.value !== ')') {
                errors.assert.linesBetween({
                    token: prevToken,
                    nextToken: token,
                    atLeast: 2,
                    message: 'Keyword `' + token.value + '` should have an empty line above it'
                });
            }
        });
    }
};

disallow-padding-newlines-before-keywords.js
/**
 * Disallow an empty line above the specified keywords.
 *
 * Types: `Array` or `Boolean`
 *
 * Values: Array of quoted types or `true` to disallow padding new lines after all of the keywords below.
 *
 * #### Example
 *
 * ```js
 * "disallowPaddingNewlinesBeforeKeywords": [
 *     "do",
 *     "for",
 *     "if",
 *     "else",
 *     "switch",
 *     "case",
 *     "try",
 *     "catch",
 *     "void",
 *     "while",
 *     "with",
 *     "return",
 *     "typeof",
 *     "function"
 * ]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * function(a) {
 *     if (!a) {
 *         return false;
 *     }
 *     for (var i = 0; i < b; i++) {
 *         if (!a[i]) {
 *             return false;
 *         }
 *     }
 *     return true;
 * }
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * function(a) {
 *     if (!a) {
 *
 *         return false;
 *     }
 *
 *     for (var i = 0; i < b; i++) {
 *         if (!a[i]) {
 *
 *             return false;
 *         }
 *     }
 *
 *     return true;
 * }
 * ```
 */
var assert = require('assert');
var defaultKeywords = require('../utils').spacedKeywords;
Function (anonymous_653)
✓ Was calledmodule.exports = function() { };
module.exports = function() { };
module.exports.prototype = {
Function (anonymous_654)
✓ Was called    configure: function(keywords) {···
        assert(Array.isArray(keywords) || keywords === true,
            this.getOptionName() + ' option requires array or true value');

        if (keywords === true) {
            keywords = defaultKeywords;
        }

        this._keywords = keywords;
    },
    configure: function(keywords) {
Branch LogicalExpression
✓ Was returned        assert(Array.isArray(keywords) || keywords === true,
✓ Was returned        assert(Array.isArray(keywords) || keywords === true,
        assert(Array.isArray(keywords) || keywords === true,
            this.getOptionName() + ' option requires array or true value');
Branch IfStatement
✓ Positive was executed (if)        if (keywords === true) {···
            keywords = defaultKeywords;
        }
✓ Negative was executed (else)        }···

        this._keywords = keywords;
        if (keywords === true) {
            keywords = defaultKeywords;
        }
        this._keywords = keywords;
    },
Function (anonymous_655)
✓ Was called    getOptionName: function() {···
        return 'disallowPaddingNewlinesBeforeKeywords';
    },
    getOptionName: function() {
        return 'disallowPaddingNewlinesBeforeKeywords';
    },
Function (anonymous_656)
✓ Was called    check: function(file, errors) {···
        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {
            errors.assert.linesBetween({
                token: file.getPrevToken(token),
                nextToken: token,
                atMost: 1,
                message: 'Keyword `' + token.value + '` should not have an empty line above it'
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_657)
✓ Was called        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {···
            errors.assert.linesBetween({
                token: file.getPrevToken(token),
                nextToken: token,
                atMost: 1,
                message: 'Keyword `' + token.value + '` should not have an empty line above it'
            });
        });
        file.iterateTokensByTypeAndValue('Keyword', this._keywords, function(token) {
            errors.assert.linesBetween({
                token: file.getPrevToken(token),
                nextToken: token,
                atMost: 1,
                message: 'Keyword `' + token.value + '` should not have an empty line above it'
            });
        });
    }
};

disallow-padding-newlines-before-line-comments.js
/**
 * Disallows newline before line comments
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowPaddingNewLinesBeforeLineComments": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var a = 2;
 * // comment
 * return a;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var a = 2;
 *
 * //comment
 * return a;
 * ```
 */
var assert = require('assert');
Function (anonymous_658)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_659)
✓ Was called    configure: function(value) {···
        assert(
            value === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(value) {
        assert(
            value === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_660)
✓ Was called    getOptionName: function() {···
        return 'disallowPaddingNewLinesBeforeLineComments';
    },
    getOptionName: function() {
        return 'disallowPaddingNewLinesBeforeLineComments';
    },
Function (anonymous_661)
✓ Was called    check: function(file, errors) {···
        file.iterateTokensByType('Line', function(comment) {
            if (comment.loc.start.line === 1) {
                return;
            }

            errors.assert.linesBetween({
                token: file.getPrevToken(comment, {includeComments: true}),
                nextToken: comment,
                atMost: 1,
                message: 'Line comments must not be preceded with a blank line'
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_662)
✓ Was called        file.iterateTokensByType('Line', function(comment) {···
            if (comment.loc.start.line === 1) {
                return;
            }

            errors.assert.linesBetween({
                token: file.getPrevToken(comment, {includeComments: true}),
                nextToken: comment,
                atMost: 1,
                message: 'Line comments must not be preceded with a blank line'
            });
        });
        file.iterateTokensByType('Line', function(comment) {
Branch IfStatement
✓ Positive was executed (if)            if (comment.loc.start.line === 1) {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.assert.linesBetween({
            if (comment.loc.start.line === 1) {
                return;
            }
            errors.assert.linesBetween({
                token: file.getPrevToken(comment, {includeComments: true}),
                nextToken: comment,
                atMost: 1,
                message: 'Line comments must not be preceded with a blank line'
            });
        });
    }
};

require-padding-newlines-before-line-comments.js
/**
 * Requires newline before line comments
 *
 * Types: `Boolean` or `Object`
 *
 * Values:
 * - `true`: always require a newline before line comments
 * - `Object`:
 *      - `"allExcept"`: `"firstAfterCurly"` Comments may be first line of block without extra padding
 *
 * #### Examples
 * ```js
 * "requirePaddingNewLinesBeforeLineComments": true
 * "requirePaddingNewLinesBeforeLineComments": { "allExcept": "firstAfterCurly" }
 * ```
 *
 * ##### Valid for `true`
 *
 * ```js
 * var a = 2;
 * var b = 3; // comment
 *
 * // comment
 * return a;
 *
 * function() {
 *
 *   // comment
 * }
 * ```
 *
 * ##### Valid for `{ "allExcept": "firstAfterCurly" }`
 *
 * ```js
 * var a = 2;
 *
 * // comment
 * return a;
 *
 * function() {
 *   // comment
 * }
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var a = 2;
 * //comment
 * return a;
 *
 * function() {
 *   // comment
 * }
 * ```
 */
var assert = require('assert');
Function (anonymous_663)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_664)
✓ Was called    configure: function(value) {···
        this._allowFirstAfterCurly = false;

        if (typeof value === 'object') {
            assert(typeof value.allExcept === 'string' && value.allExcept === 'firstAfterCurly',
                this.getOptionName() + ' option requires the "allExcept" ' +
                 'property to equal "firstAfterCurly"');
            this._allowFirstAfterCurly = true;
        } else {
            assert(value === true,
                this.getOptionName() + ' option requires true value or object'
            );
        }
    },
    configure: function(value) {
        this._allowFirstAfterCurly = false;
Branch IfStatement
✓ Positive was executed (if)        if (typeof value === 'object') {···
            assert(typeof value.allExcept === 'string' && value.allExcept === 'firstAfterCurly',
                this.getOptionName() + ' option requires the "allExcept" ' +
                 'property to equal "firstAfterCurly"');
            this._allowFirstAfterCurly = true;
        } else {
✓ Negative was executed (else)        } else {···
            assert(value === true,
                this.getOptionName() + ' option requires true value or object'
            );
        }
        if (typeof value === 'object') {
Branch LogicalExpression
✓ Was returned            assert(typeof value.allExcept === 'string' && value.allExcept === 'firstAfterCurly',
✓ Was returned            assert(typeof value.allExcept === 'string' && value.allExcept === 'firstAfterCurly',
            assert(typeof value.allExcept === 'string' && value.allExcept === 'firstAfterCurly',
                this.getOptionName() + ' option requires the "allExcept" ' +
                 'property to equal "firstAfterCurly"');
            this._allowFirstAfterCurly = true;
        } else {
            assert(value === true,
                this.getOptionName() + ' option requires true value or object'
            );
        }
    },
Function (anonymous_665)
✓ Was called    getOptionName: function() {···
        return 'requirePaddingNewLinesBeforeLineComments';
    },
    getOptionName: function() {
        return 'requirePaddingNewLinesBeforeLineComments';
    },
Function (anonymous_666)
✓ Was called    check: function(file, errors) {···
        var allowFirstAfterCurly = this._allowFirstAfterCurly;

        file.iterateTokensByType('Line', function(comment) {
            if (comment.loc.start.line === 1) {
                return;
            }

            var firstToken = file.getFirstTokenOnLine(comment.loc.start.line);

            // Should not consider code and comment on the same line (#1194)
            if (firstToken !== undefined && firstToken.type !== 'EOF') {
                return;
            }

            var prevToken = file.getPrevToken(comment, {includeComments: true});

            if (prevToken.type === 'Line') {
                return;
            }

            if (allowFirstAfterCurly && prevToken.type === 'Punctuator' && prevToken.value === '{') {
                return;
            }

            errors.assert.linesBetween({
                token: prevToken,
                nextToken: comment,
                atLeast: 2,
                message: 'Line comments must be preceded with a blank line'
            });
        });
    }
    check: function(file, errors) {
        var allowFirstAfterCurly = this._allowFirstAfterCurly;
Function (anonymous_667)
✓ Was called        file.iterateTokensByType('Line', function(comment) {···
            if (comment.loc.start.line === 1) {
                return;
            }

            var firstToken = file.getFirstTokenOnLine(comment.loc.start.line);

            // Should not consider code and comment on the same line (#1194)
            if (firstToken !== undefined && firstToken.type !== 'EOF') {
                return;
            }

            var prevToken = file.getPrevToken(comment, {includeComments: true});

            if (prevToken.type === 'Line') {
                return;
            }

            if (allowFirstAfterCurly && prevToken.type === 'Punctuator' && prevToken.value === '{') {
                return;
            }

            errors.assert.linesBetween({
                token: prevToken,
                nextToken: comment,
                atLeast: 2,
                message: 'Line comments must be preceded with a blank line'
            });
        });
        file.iterateTokensByType('Line', function(comment) {
Branch IfStatement
✓ Positive was executed (if)            if (comment.loc.start.line === 1) {···
                return;
            }
✓ Negative was executed (else)            }···

            var firstToken = file.getFirstTokenOnLine(comment.loc.start.line);
            if (comment.loc.start.line === 1) {
                return;
            }
            var firstToken = file.getFirstTokenOnLine(comment.loc.start.line);
            // Should not consider code and comment on the same line (#1194)
Branch IfStatement
✓ Positive was executed (if)            if (firstToken !== undefined && firstToken.type !== 'EOF') {···
                return;
            }
✓ Negative was executed (else)            }···

            var prevToken = file.getPrevToken(comment, {includeComments: true});
Branch LogicalExpression
✓ Was returned            if (firstToken !== undefined && firstToken.type !== 'EOF') {
✓ Was returned            if (firstToken !== undefined && firstToken.type !== 'EOF') {
            if (firstToken !== undefined && firstToken.type !== 'EOF') {
                return;
            }
            var prevToken = file.getPrevToken(comment, {includeComments: true});
Branch IfStatement
✓ Positive was executed (if)            if (prevToken.type === 'Line') {···
                return;
            }
✓ Negative was executed (else)            }···

            if (allowFirstAfterCurly && prevToken.type === 'Punctuator' && prevToken.value === '{') {
            if (prevToken.type === 'Line') {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (allowFirstAfterCurly && prevToken.type === 'Punctuator' && prevToken.value === '{') {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.assert.linesBetween({
Branch LogicalExpression
✓ Was returned            if (allowFirstAfterCurly && prevToken.type === 'Punctuator' && prevToken.value === '{') {
✓ Was returned            if (allowFirstAfterCurly && prevToken.type === 'Punctuator' && prevToken.value === '{') {
Branch LogicalExpression
✓ Was returned            if (allowFirstAfterCurly && prevToken.type === 'Punctuator' && prevToken.value === '{') {
✓ Was returned            if (allowFirstAfterCurly && prevToken.type === 'Punctuator' && prevToken.value === '{') {
            if (allowFirstAfterCurly && prevToken.type === 'Punctuator' && prevToken.value === '{') {
                return;
            }
            errors.assert.linesBetween({
                token: prevToken,
                nextToken: comment,
                atLeast: 2,
                message: 'Line comments must be preceded with a blank line'
            });
        });
    }
};

disallow-trailing-comma.js
/**
 * Disallows an extra comma following the final element of an array or object literal.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * JSHint: [`es3`](http://jshint.com/docs/options/#es3)
 *
 * #### Example
 *
 * ```js
 * "disallowTrailingComma": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var foo = [1, 2, 3];
 * var bar = {a: "a", b: "b"}
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var foo = [1, 2, 3, ];
 * var bar = {a: "a", b: "b", }
 * ```
 */
var assert = require('assert');
Function (anonymous_668)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_669)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_670)
✓ Was called    getOptionName: function() {···
        return 'disallowTrailingComma';
    },
    getOptionName: function() {
        return 'disallowTrailingComma';
    },
Function (anonymous_671)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType(['ObjectExpression', 'ArrayExpression'], function(node) {
            var closingToken = file.getLastNodeToken(node);

            errors.assert.noTokenBefore({
                token: closingToken,
                expectedTokenBefore: {type: 'Punctuator', value: ','},
                message: 'Extra comma following the final element of an array or object literal'
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_672)
✓ Was called        file.iterateNodesByType(['ObjectExpression', 'ArrayExpression'], function(node) {···
            var closingToken = file.getLastNodeToken(node);

            errors.assert.noTokenBefore({
                token: closingToken,
                expectedTokenBefore: {type: 'Punctuator', value: ','},
                message: 'Extra comma following the final element of an array or object literal'
            });
        });
        file.iterateNodesByType(['ObjectExpression', 'ArrayExpression'], function(node) {
            var closingToken = file.getLastNodeToken(node);
            errors.assert.noTokenBefore({
                token: closingToken,
                expectedTokenBefore: {type: 'Punctuator', value: ','},
                message: 'Extra comma following the final element of an array or object literal'
            });
        });
    }
};

require-trailing-comma.js
/**
 * Requires an extra comma following the final element of an array or object literal.
 *
 * Types: `Boolean` or `Object`
 *
 * Values:
 *
 * - `true`: validates all arrays and objects
 * - `Object`:
 *     - `ignoreSingleValue`: allows single property objects and single element arrays to not require a trailing comma
 *     - `ignoreSingleLine`: allows objects and arrays on a single line to not require a trailing comma
 *
 * #### Example
 *
 * ```js
 * "requireTrailingComma": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var foo = [1, 2, 3,];
 * var bar = {a: "a", b: "b",}
 * ```
 *
 * ##### Valid with ignoreSingleValue
 *
 * ```js
 * var car = [1];
 * var dar = {a: "a"};
 * ```
 *
 * ##### Valid with ignoreSingleLine
 *
 * ```js
 * var car = [1, 2, 3];
 * var dar = {a: "a", b: "b"};
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var foo = [1, 2, 3];
 * var bar = {a: "a", b: "b"}
 * ```
 */
var assert = require('assert');
Function (anonymous_673)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_674)
✓ Was called    configure: function(options) {···

        if (typeof options === 'object') {
            if ('ignoreSingleValue' in options) {
                assert(
                    options.ignoreSingleValue === true,
                    this.getOptionName() + ' option ignoreSingleValue requires true value or should be removed'
                );
                this._ignoreSingleValue = true;
            }
            if ('ignoreSingleLine' in options) {
                assert(
                    options.ignoreSingleLine === true,
                    this.getOptionName() + ' option ignoreSingleLine requires true value or should be removed'
                );
                this._ignoreSingleLine = true;
            }
        } else {
            assert(
                options === true,
                this.getOptionName() + ' option requires a true value or should be removed'
            );
        }
    },
    configure: function(options) {
Branch IfStatement
✓ Positive was executed (if)        if (typeof options === 'object') {···
            if ('ignoreSingleValue' in options) {
                assert(
                    options.ignoreSingleValue === true,
                    this.getOptionName() + ' option ignoreSingleValue requires true value or should be removed'
                );
                this._ignoreSingleValue = true;
            }
            if ('ignoreSingleLine' in options) {
                assert(
                    options.ignoreSingleLine === true,
                    this.getOptionName() + ' option ignoreSingleLine requires true value or should be removed'
                );
                this._ignoreSingleLine = true;
            }
        } else {
✓ Negative was executed (else)        } else {···
            assert(
                options === true,
                this.getOptionName() + ' option requires a true value or should be removed'
            );
        }
        if (typeof options === 'object') {
Branch IfStatement
✓ Positive was executed (if)            if ('ignoreSingleValue' in options) {···
                assert(
                    options.ignoreSingleValue === true,
                    this.getOptionName() + ' option ignoreSingleValue requires true value or should be removed'
                );
                this._ignoreSingleValue = true;
            }
✓ Negative was executed (else)            }···
            if ('ignoreSingleLine' in options) {
            if ('ignoreSingleValue' in options) {
                assert(
                    options.ignoreSingleValue === true,
                    this.getOptionName() + ' option ignoreSingleValue requires true value or should be removed'
                );
                this._ignoreSingleValue = true;
            }
Branch IfStatement
✓ Positive was executed (if)            if ('ignoreSingleLine' in options) {···
                assert(
                    options.ignoreSingleLine === true,
                    this.getOptionName() + ' option ignoreSingleLine requires true value or should be removed'
                );
                this._ignoreSingleLine = true;
            }
✓ Negative was executed (else)            }···
        } else {
            if ('ignoreSingleLine' in options) {
                assert(
                    options.ignoreSingleLine === true,
                    this.getOptionName() + ' option ignoreSingleLine requires true value or should be removed'
                );
                this._ignoreSingleLine = true;
            }
        } else {
            assert(
                options === true,
                this.getOptionName() + ' option requires a true value or should be removed'
            );
        }
    },
Function (anonymous_675)
✓ Was called    getOptionName: function() {···
        return 'requireTrailingComma';
    },
    getOptionName: function() {
        return 'requireTrailingComma';
    },
Function (anonymous_676)
✓ Was called    check: function(file, errors) {···
        var _this = this;

        file.iterateNodesByType(['ObjectExpression', 'ArrayExpression'], function(node) {
            var isObject = node.type === 'ObjectExpression';
            var entities = isObject ? node.properties : node.elements;

            if (entities.length === 0) {
                return;
            }

            if (_this._ignoreSingleValue && entities.length === 1) {
                return;
            }

            if (_this._ignoreSingleLine && node.loc.start.line === node.loc.end.line) {
                return;
            }

            var closingToken = file.getLastNodeToken(node);

            errors.assert.tokenBefore({
                token: closingToken,
                expectedTokenBefore: {type: 'Punctuator', value: ','},
                message: 'Missing comma before closing ' + (isObject ? ' curly brace' : ' bracket')
            });
        });
    }
    check: function(file, errors) {
        var _this = this;
Function (anonymous_677)
✓ Was called        file.iterateNodesByType(['ObjectExpression', 'ArrayExpression'], function(node) {···
            var isObject = node.type === 'ObjectExpression';
            var entities = isObject ? node.properties : node.elements;

            if (entities.length === 0) {
                return;
            }

            if (_this._ignoreSingleValue && entities.length === 1) {
                return;
            }

            if (_this._ignoreSingleLine && node.loc.start.line === node.loc.end.line) {
                return;
            }

            var closingToken = file.getLastNodeToken(node);

            errors.assert.tokenBefore({
                token: closingToken,
                expectedTokenBefore: {type: 'Punctuator', value: ','},
                message: 'Missing comma before closing ' + (isObject ? ' curly brace' : ' bracket')
            });
        });
        file.iterateNodesByType(['ObjectExpression', 'ArrayExpression'], function(node) {
            var isObject = node.type === 'ObjectExpression';
Branch ConditionalExpression
✓ Positive was returned (? ...)            var entities = isObject ? node.properties : node.elements;
✓ Negative was returned (: ...)            var entities = isObject ? node.properties : node.elements;
            var entities = isObject ? node.properties : node.elements;
Branch IfStatement
✓ Positive was executed (if)            if (entities.length === 0) {···
                return;
            }
✓ Negative was executed (else)            }···

            if (_this._ignoreSingleValue && entities.length === 1) {
            if (entities.length === 0) {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (_this._ignoreSingleValue && entities.length === 1) {···
                return;
            }
✓ Negative was executed (else)            }···

            if (_this._ignoreSingleLine && node.loc.start.line === node.loc.end.line) {
Branch LogicalExpression
✓ Was returned            if (_this._ignoreSingleValue && entities.length === 1) {
✓ Was returned            if (_this._ignoreSingleValue && entities.length === 1) {
            if (_this._ignoreSingleValue && entities.length === 1) {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (_this._ignoreSingleLine && node.loc.start.line === node.loc.end.line) {···
                return;
            }
✓ Negative was executed (else)            }···

            var closingToken = file.getLastNodeToken(node);
Branch LogicalExpression
✓ Was returned            if (_this._ignoreSingleLine && node.loc.start.line === node.loc.end.line) {
✓ Was returned            if (_this._ignoreSingleLine && node.loc.start.line === node.loc.end.line) {
            if (_this._ignoreSingleLine && node.loc.start.line === node.loc.end.line) {
                return;
            }
            var closingToken = file.getLastNodeToken(node);
            errors.assert.tokenBefore({
                token: closingToken,
                expectedTokenBefore: {type: 'Punctuator', value: ','},
Branch ConditionalExpression
✓ Positive was returned (? ...)                message: 'Missing comma before closing ' + (isObject ? ' curly brace' : ' bracket')
✓ Negative was returned (: ...)                message: 'Missing comma before closing ' + (isObject ? ' curly brace' : ' bracket')
                message: 'Missing comma before closing ' + (isObject ? ' curly brace' : ' bracket')
            });
        });
    }
};

require-dollar-before-jquery-assignment.js
/**
 * Require a $ before variable names that are jquery assignments.
 *
 * Types: `Boolean` or `String`
 *
 * Values: `true` or `"ignoreProperties"`
 *
 * #### Example
 *
 * ```js
 * "requireDollarBeforejQueryAssignment": true
 * ```
 *
 * ##### Valid example for mode `true`
 *
 * ```js
 * var $x = $(".foo");
 * var y = {
 *   $x: $(".bar")
 * };
 * ```
 *
 * ##### Invalid example for mode `true`
 *
 * ```js
 * var x = $(".foo");
 * var y = {
 *   x: $(".bar")
 * };
 * ```
 *
 * ##### Valid example for mode `ignoreProperties`
 *
 * ```js
 * var $x = $(".foo");
 * var y = {
 *   x: $(".bar")
 * };
 * ```
 *
 * ##### Invalid example for mode `ignoreProperties`
 *
 * ```js
 * var x = $(".foo");
 * ```
 */
var assert = require('assert');
Function (anonymous_678)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
    _ignoreProperties : false,
Function (anonymous_679)
✓ Was called    configure: function(options) {···
        assert(
            options === true || options === 'ignoreProperties',
            this.getOptionName() + ' option requires true or "ignoreProperties" value, or should be removed'
        );

        this._ignoreProperties = (options === 'ignoreProperties');
    },
    configure: function(options) {
        assert(
Branch LogicalExpression
✓ Was returned            options === true || options === 'ignoreProperties',
✓ Was returned            options === true || options === 'ignoreProperties',
            options === true || options === 'ignoreProperties',
            this.getOptionName() + ' option requires true or "ignoreProperties" value, or should be removed'
        );
        this._ignoreProperties = (options === 'ignoreProperties');
    },
Function (anonymous_680)
✓ Was called    getOptionName: function() {···
        return 'requireDollarBeforejQueryAssignment';
    },
    getOptionName: function() {
        return 'requireDollarBeforejQueryAssignment';
    },
Function (anonymous_681)
✓ Was called    check: function(file, errors) {···
        var ignoreProperties = this._ignoreProperties;

        file.iterateNodesByType(['VariableDeclarator', 'AssignmentExpression', 'ObjectExpression'], function(token) {
            var type = token.type;
            var left;
            var varName;
            var right;

            if (type === 'VariableDeclarator') {
                left = token.id;
                varName = left.name;
                right = token.init;

            } else if (ignoreProperties) {
                return;

            } else if (type === 'AssignmentExpression') {
                left = token.left;
                if (left.computed) {
                    return;
                }

                varName = left.name || left.property.name;
                right = token.right;

            } else {// type === 'ObjectExpression'
                var props = token.properties[0];

                if (!props) {
                    return;
                }

                left = props.key;

                if (!left.name) {
                    return;
                }

                varName = left.name;
                right = props.value;
            }

            if (varName.indexOf('$') === 0 || varName.indexOf('_$') === 0) {
                return;
            }

            if (!right || right.type !== 'CallExpression') {
                return;
            }

            var nextToken = file.getTokenByRangeStart(right.callee.range[0]);
            if (nextToken.value !== '$') {
                return;
            }

            nextToken = file.getNextToken(nextToken);
            if (nextToken.value !== '(') {
                return;
            }

            while (!(nextToken.type === 'Punctuator' && nextToken.value === ')')) {
                nextToken = file.getNextToken(nextToken);
            }

            nextToken = file.getNextToken(nextToken);

            if (!nextToken || !(nextToken.type === 'Punctuator' && nextToken.value === '.')) {
                errors.add(
                    'jQuery identifiers must start with a $',
                    left.loc.start.line,
                    left.loc.start.column
                );
            }
        });
    }
    check: function(file, errors) {
        var ignoreProperties = this._ignoreProperties;
Function (anonymous_682)
✓ Was called        file.iterateNodesByType(['VariableDeclarator', 'AssignmentExpression', 'ObjectExpression'], function(token) {···
            var type = token.type;
            var left;
            var varName;
            var right;

            if (type === 'VariableDeclarator') {
                left = token.id;
                varName = left.name;
                right = token.init;

            } else if (ignoreProperties) {
                return;

            } else if (type === 'AssignmentExpression') {
                left = token.left;
                if (left.computed) {
                    return;
                }

                varName = left.name || left.property.name;
                right = token.right;

            } else {// type === 'ObjectExpression'
                var props = token.properties[0];

                if (!props) {
                    return;
                }

                left = props.key;

                if (!left.name) {
                    return;
                }

                varName = left.name;
                right = props.value;
            }

            if (varName.indexOf('$') === 0 || varName.indexOf('_$') === 0) {
                return;
            }

            if (!right || right.type !== 'CallExpression') {
                return;
            }

            var nextToken = file.getTokenByRangeStart(right.callee.range[0]);
            if (nextToken.value !== '$') {
                return;
            }

            nextToken = file.getNextToken(nextToken);
            if (nextToken.value !== '(') {
                return;
            }

            while (!(nextToken.type === 'Punctuator' && nextToken.value === ')')) {
                nextToken = file.getNextToken(nextToken);
            }

            nextToken = file.getNextToken(nextToken);

            if (!nextToken || !(nextToken.type === 'Punctuator' && nextToken.value === '.')) {
                errors.add(
                    'jQuery identifiers must start with a $',
                    left.loc.start.line,
                    left.loc.start.column
                );
            }
        });
        file.iterateNodesByType(['VariableDeclarator', 'AssignmentExpression', 'ObjectExpression'], function(token) {
            var type = token.type;
            var left;
            var varName;
            var right;
Branch IfStatement
✓ Positive was executed (if)            if (type === 'VariableDeclarator') {···
                left = token.id;
                varName = left.name;
                right = token.init;

            } else if (ignoreProperties) {
✓ Negative was executed (else)            } else if (ignoreProperties) {···
                return;

            } else if (type === 'AssignmentExpression') {
                left = token.left;
                if (left.computed) {
                    return;
                }

                varName = left.name || left.property.name;
                right = token.right;

            } else {// type === 'ObjectExpression'
                var props = token.properties[0];

                if (!props) {
                    return;
                }

                left = props.key;

                if (!left.name) {
                    return;
                }

                varName = left.name;
                right = props.value;
            }
            if (type === 'VariableDeclarator') {
                left = token.id;
                varName = left.name;
                right = token.init;
Branch IfStatement
✓ Positive was executed (if)            } else if (ignoreProperties) {···
                return;

            } else if (type === 'AssignmentExpression') {
✓ Negative was executed (else)            } else if (type === 'AssignmentExpression') {···
                left = token.left;
                if (left.computed) {
                    return;
                }

                varName = left.name || left.property.name;
                right = token.right;

            } else {// type === 'ObjectExpression'
                var props = token.properties[0];

                if (!props) {
                    return;
                }

                left = props.key;

                if (!left.name) {
                    return;
                }

                varName = left.name;
                right = props.value;
            }
            } else if (ignoreProperties) {
                return;
Branch IfStatement
✓ Positive was executed (if)            } else if (type === 'AssignmentExpression') {···
                left = token.left;
                if (left.computed) {
                    return;
                }

                varName = left.name || left.property.name;
                right = token.right;

            } else {// type === 'ObjectExpression'
✓ Negative was executed (else)            } else {// type === 'ObjectExpression'···
                var props = token.properties[0];

                if (!props) {
                    return;
                }

                left = props.key;

                if (!left.name) {
                    return;
                }

                varName = left.name;
                right = props.value;
            }
            } else if (type === 'AssignmentExpression') {
                left = token.left;
Branch IfStatement
✓ Positive was executed (if)                if (left.computed) {···
                    return;
                }
✓ Negative was executed (else)                }···

                varName = left.name || left.property.name;
                if (left.computed) {
                    return;
                }
Branch LogicalExpression
✓ Was returned                varName = left.name || left.property.name;
✓ Was returned                varName = left.name || left.property.name;
                varName = left.name || left.property.name;
                right = token.right;
            } else {// type === 'ObjectExpression'
                var props = token.properties[0];
Branch IfStatement
✓ Positive was executed (if)                if (!props) {···
                    return;
                }
✓ Negative was executed (else)                }···

                left = props.key;
                if (!props) {
                    return;
                }
                left = props.key;
Branch IfStatement
✓ Positive was executed (if)                if (!left.name) {···
                    return;
                }
✓ Negative was executed (else)                }···

                varName = left.name;
                if (!left.name) {
                    return;
                }
                varName = left.name;
                right = props.value;
            }
Branch IfStatement
✓ Positive was executed (if)            if (varName.indexOf('$') === 0 || varName.indexOf('_$') === 0) {···
                return;
            }
✓ Negative was executed (else)            }···

            if (!right || right.type !== 'CallExpression') {
Branch LogicalExpression
✓ Was returned            if (varName.indexOf('$') === 0 || varName.indexOf('_$') === 0) {
✓ Was returned            if (varName.indexOf('$') === 0 || varName.indexOf('_$') === 0) {
            if (varName.indexOf('$') === 0 || varName.indexOf('_$') === 0) {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (!right || right.type !== 'CallExpression') {···
                return;
            }
✓ Negative was executed (else)            }···

            var nextToken = file.getTokenByRangeStart(right.callee.range[0]);
Branch LogicalExpression
✓ Was returned            if (!right || right.type !== 'CallExpression') {
✓ Was returned            if (!right || right.type !== 'CallExpression') {
            if (!right || right.type !== 'CallExpression') {
                return;
            }
            var nextToken = file.getTokenByRangeStart(right.callee.range[0]);
Branch IfStatement
✓ Positive was executed (if)            if (nextToken.value !== '$') {···
                return;
            }
✓ Negative was executed (else)            }···

            nextToken = file.getNextToken(nextToken);
            if (nextToken.value !== '$') {
                return;
            }
            nextToken = file.getNextToken(nextToken);
Branch IfStatement
✓ Positive was executed (if)            if (nextToken.value !== '(') {···
                return;
            }
✓ Negative was executed (else)            }···

            while (!(nextToken.type === 'Punctuator' && nextToken.value === ')')) {
            if (nextToken.value !== '(') {
                return;
            }
Branch LogicalExpression
✓ Was returned            while (!(nextToken.type === 'Punctuator' && nextToken.value === ')')) {
✓ Was returned            while (!(nextToken.type === 'Punctuator' && nextToken.value === ')')) {
            while (!(nextToken.type === 'Punctuator' && nextToken.value === ')')) {
                nextToken = file.getNextToken(nextToken);
            }
            nextToken = file.getNextToken(nextToken);
Branch IfStatement
✓ Positive was executed (if)            if (!nextToken || !(nextToken.type === 'Punctuator' && nextToken.value === '.')) {···
                errors.add(
                    'jQuery identifiers must start with a $',
                    left.loc.start.line,
                    left.loc.start.column
                );
            }
✓ Negative was executed (else)            }···
        });
Branch LogicalExpression
✓ Was returned            if (!nextToken || !(nextToken.type === 'Punctuator' && nextToken.value === '.')) {
✗ Was not returned            if (!nextToken || !(nextToken.type === 'Punctuator' && nextToken.value === '.')) {
Branch LogicalExpression
✓ Was returned            if (!nextToken || !(nextToken.type === 'Punctuator' && nextToken.value === '.')) {
✓ Was returned            if (!nextToken || !(nextToken.type === 'Punctuator' && nextToken.value === '.')) {
            if (!nextToken || !(nextToken.type === 'Punctuator' && nextToken.value === '.')) {
                errors.add(
                    'jQuery identifiers must start with a $',
                    left.loc.start.line,
                    left.loc.start.column
                );
            }
        });
    }
};

disallow-comma-before-line-break.js
/**
 * Disallows commas as last token on a line in lists.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * JSHint: [`laxcomma`](http://www.jshint.com/docs/options/#laxcomma)
 *
 * #### Example
 *
 * ```js
 * "disallowCommaBeforeLineBreak": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var x = {
 *     one: 1
 *     , two: 2
 * };
 * var y = { three: 3, four: 4};
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = {
 *     one: 1,
 *     two: 2
 * };
 * ```
 */
var assert = require('assert');
Function (anonymous_683)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_684)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_685)
✓ Was called    getOptionName: function() {···
        return 'disallowCommaBeforeLineBreak';
    },
    getOptionName: function() {
        return 'disallowCommaBeforeLineBreak';
    },
Function (anonymous_686)
✓ Was called    check: function(file, errors) {···
        file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {
            errors.assert.sameLine({
                token: token,
                nextToken: file.getNextToken(token),
                message: 'Commas should be placed on new line'
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_687)
✓ Was called        file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {···
            errors.assert.sameLine({
                token: token,
                nextToken: file.getNextToken(token),
                message: 'Commas should be placed on new line'
            });
        });
        file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {
            errors.assert.sameLine({
                token: token,
                nextToken: file.getNextToken(token),
                message: 'Commas should be placed on new line'
            });
        });
    }
};

require-comma-before-line-break.js
/**
 * Requires commas as last token on a line in lists.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * JSHint: [`laxcomma`](http://www.jshint.com/docs/options/#laxcomma)
 *
 * #### Example
 *
 * ```js
 * "requireCommaBeforeLineBreak": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var x = {
 *     one: 1,
 *     two: 2
 * };
 * var y = { three: 3, four: 4};
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = {
 *     one: 1
 *     , two: 2
 * };
 * ```
 */
var assert = require('assert');
Function (anonymous_688)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_689)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_690)
✓ Was called    getOptionName: function() {···
        return 'requireCommaBeforeLineBreak';
    },
    getOptionName: function() {
        return 'requireCommaBeforeLineBreak';
    },
Function (anonymous_691)
✓ Was called    check: function(file, errors) {···
        file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {
            errors.assert.sameLine({
                token: file.getPrevToken(token),
                nextToken: token,
                message: 'Commas should not be placed on new line'
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_692)
✓ Was called        file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {···
            errors.assert.sameLine({
                token: file.getPrevToken(token),
                nextToken: token,
                message: 'Commas should not be placed on new line'
            });
        });
        file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {
            errors.assert.sameLine({
                token: file.getPrevToken(token),
                nextToken: token,
                message: 'Commas should not be placed on new line'
            });
        });
    }
};

disallow-space-before-block-statements.js
/**
 * Disallows space before block statements (for loops, control structures).
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowSpaceBeforeBlockStatements": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * if (cond){
 *     foo();
 * } else{
 *    bar();
 * }
 *
 * for (var e in elements){
 *     bar(e);
 * }
 *
 * while (cond){
 *     foo();
 * }
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * if (cond) {
 *     foo();
 * } else {
 *    bar();
 * }
 *
 * for (var e in elements) {
 *     bar(e);
 * }
 *
 * while (cond) {
 *     foo();
 * }
 * ```
 */
var assert = require('assert');
Function (anonymous_693)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_694)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_695)
✓ Was called    getOptionName: function() {···
        return 'disallowSpaceBeforeBlockStatements';
    },
    getOptionName: function() {
        return 'disallowSpaceBeforeBlockStatements';
    },
Function (anonymous_696)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('BlockStatement', function(node) {
            var first = file.getFirstNodeToken(node);

            errors.assert.noWhitespaceBetween({
                token: file.getPrevToken(first),
                nextToken: first,
                disallowNewLine: true,
                message: 'Extra space before opening curly brace for block expressions'
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_697)
✓ Was called        file.iterateNodesByType('BlockStatement', function(node) {···
            var first = file.getFirstNodeToken(node);

            errors.assert.noWhitespaceBetween({
                token: file.getPrevToken(first),
                nextToken: first,
                disallowNewLine: true,
                message: 'Extra space before opening curly brace for block expressions'
            });
        });
        file.iterateNodesByType('BlockStatement', function(node) {
            var first = file.getFirstNodeToken(node);
            errors.assert.noWhitespaceBetween({
                token: file.getPrevToken(first),
                nextToken: first,
                disallowNewLine: true,
                message: 'Extra space before opening curly brace for block expressions'
            });
        });
    }
};

require-space-before-block-statements.js
/**
 * Requires space(s) before block statements (for loops, control structures).
 *
 * Type: `Boolean` or `Integer`
 *
 * Values:
 *
 * - `true` require a single space
 * - `Integer` require *at least* specified number of spaces
 *
 * #### Example
 *
 * ```js
 * "requireSpaceBeforeBlockStatements": 1
 * ```
 *
 * ##### Valid
 *
 * ```js
 * if (cond) {
 *     foo();
 * } else {
 *     bar();
 * }
 *
 * for (var e in elements) {
 *     bar(e);
 * }
 *
 * while (cond) {
 *     foo();
 * }
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * if (cond){
 *     foo();
 * } else{
 *     bar();
 * }
 *
 * for (var e in elements){
 *     bar(e);
 * }
 *
 * while (cond){
 *     foo();
 * }
 * ```
 */
var assert = require('assert');
Function (anonymous_698)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_699)
✓ Was called    configure: function(requireSpaceBeforeBlockStatements) {···
        assert(
            typeof requireSpaceBeforeBlockStatements === 'boolean' ||
            typeof requireSpaceBeforeBlockStatements === 'number',
            this.getOptionName() + ' option requires number or bolean'
        );
        assert(
            requireSpaceBeforeBlockStatements >= 1,
            this.getOptionName() +
              ' option requires true value or a number greater than equal to 1 or should be removed'
        );
        this._count = +requireSpaceBeforeBlockStatements;
    },
    configure: function(requireSpaceBeforeBlockStatements) {
        assert(
Branch LogicalExpression
✓ Was returned            typeof requireSpaceBeforeBlockStatements === 'number',
✓ Was returned            typeof requireSpaceBeforeBlockStatements === 'boolean' ||
            typeof requireSpaceBeforeBlockStatements === 'boolean' ||
            typeof requireSpaceBeforeBlockStatements === 'number',
            this.getOptionName() + ' option requires number or bolean'
        );
        assert(
            requireSpaceBeforeBlockStatements >= 1,
            this.getOptionName() +
              ' option requires true value or a number greater than equal to 1 or should be removed'
        );
        this._count = +requireSpaceBeforeBlockStatements;
    },
Function (anonymous_700)
✓ Was called    getOptionName: function() {···
        return 'requireSpaceBeforeBlockStatements';
    },
    getOptionName: function() {
        return 'requireSpaceBeforeBlockStatements';
    },
Function (anonymous_701)
✓ Was called    check: function(file, errors) {···
        var count = this._count;
        file.iterateNodesByType('BlockStatement', function(node) {
            var first = file.getFirstNodeToken(node);

            errors.assert.spacesBetween({
                token: file.getPrevToken(first),
                nextToken: first,
                atLeast: count,
                disallowNewLine: true,
                message: 'One (or more) spaces required before opening brace for block expressions'
            });
        });
    }
    check: function(file, errors) {
        var count = this._count;
Function (anonymous_702)
✓ Was called        file.iterateNodesByType('BlockStatement', function(node) {···
            var first = file.getFirstNodeToken(node);

            errors.assert.spacesBetween({
                token: file.getPrevToken(first),
                nextToken: first,
                atLeast: count,
                disallowNewLine: true,
                message: 'One (or more) spaces required before opening brace for block expressions'
            });
        });
        file.iterateNodesByType('BlockStatement', function(node) {
            var first = file.getFirstNodeToken(node);
            errors.assert.spacesBetween({
                token: file.getPrevToken(first),
                nextToken: first,
                atLeast: count,
                disallowNewLine: true,
                message: 'One (or more) spaces required before opening brace for block expressions'
            });
        });
    }
};

disallow-space-before-postfix-unary-operators.js
/**
 * Requires sticking unary operators to the left.
 *
 * Types: `Array` or `Boolean`
 *
 * Values: Array of quoted operators or `true` to disallow space before postfix for all unary operators
 * (i.e. increment/decrement operators)
 *
 * #### Example
 *
 * ```js
 * "disallowSpaceBeforePostfixUnaryOperators": ["++", "--"]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * x = y++; y = z--;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * x = y ++; y = z --;
 * ```
 */
var assert = require('assert');
var defaultOperators = require('../utils').incrementAndDecrementOperators;
Function (anonymous_703)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_704)
✓ Was called    configure: function(operators) {···
        var isTrue = operators === true;

        assert(
            Array.isArray(operators) || isTrue,
            this.getOptionName() + ' option requires array or true value'
        );

        if (isTrue) {
            operators = defaultOperators;
        }

        this._operatorIndex = {};
        for (var i = 0, l = operators.length; i < l; i++) {
            this._operatorIndex[operators[i]] = true;
        }
    },
    configure: function(operators) {
        var isTrue = operators === true;
        assert(
Branch LogicalExpression
✓ Was returned            Array.isArray(operators) || isTrue,
✓ Was returned            Array.isArray(operators) || isTrue,
            Array.isArray(operators) || isTrue,
            this.getOptionName() + ' option requires array or true value'
        );
Branch IfStatement
✓ Positive was executed (if)        if (isTrue) {···
            operators = defaultOperators;
        }
✓ Negative was executed (else)        }···

        this._operatorIndex = {};
        if (isTrue) {
            operators = defaultOperators;
        }
        this._operatorIndex = {};
        for (var i = 0, l = operators.length; i < l; i++) {
            this._operatorIndex[operators[i]] = true;
        }
    },
Function (anonymous_705)
✓ Was called    getOptionName: function() {···
        return 'disallowSpaceBeforePostfixUnaryOperators';
    },
    getOptionName: function() {
        return 'disallowSpaceBeforePostfixUnaryOperators';
    },
Function (anonymous_706)
✓ Was called    check: function(file, errors) {···
        var operatorIndex = this._operatorIndex;

        // 'UpdateExpression' involve only ++ and -- operators
        file.iterateNodesByType('UpdateExpression', function(node) {
            // "!node.prefix" means postfix type of (inc|dec)rement
            if (!node.prefix && operatorIndex[node.operator]) {
                var operatorToken = file.getLastNodeToken(node);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(operatorToken),
                    nextToken: operatorToken,
                    message: 'Operator ' + node.operator + ' should stick to operand'
                });
            }
        });
    }
    check: function(file, errors) {
        var operatorIndex = this._operatorIndex;
        // 'UpdateExpression' involve only ++ and -- operators
Function (anonymous_707)
✓ Was called        file.iterateNodesByType('UpdateExpression', function(node) {···
            // "!node.prefix" means postfix type of (inc|dec)rement
            if (!node.prefix && operatorIndex[node.operator]) {
                var operatorToken = file.getLastNodeToken(node);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(operatorToken),
                    nextToken: operatorToken,
                    message: 'Operator ' + node.operator + ' should stick to operand'
                });
            }
        });
        file.iterateNodesByType('UpdateExpression', function(node) {
            // "!node.prefix" means postfix type of (inc|dec)rement
Branch IfStatement
✓ Positive was executed (if)            if (!node.prefix && operatorIndex[node.operator]) {···
                var operatorToken = file.getLastNodeToken(node);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(operatorToken),
                    nextToken: operatorToken,
                    message: 'Operator ' + node.operator + ' should stick to operand'
                });
            }
✓ Negative was executed (else)            }···
        });
Branch LogicalExpression
✓ Was returned            if (!node.prefix && operatorIndex[node.operator]) {
✓ Was returned            if (!node.prefix && operatorIndex[node.operator]) {
            if (!node.prefix && operatorIndex[node.operator]) {
                var operatorToken = file.getLastNodeToken(node);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(operatorToken),
                    nextToken: operatorToken,
                    message: 'Operator ' + node.operator + ' should stick to operand'
                });
            }
        });
    }
};

require-space-before-postfix-unary-operators.js
/**
 * Disallows sticking unary operators to the left.
 *
 * Types: `Array` or `Boolean`
 *
 * Values: Array of quoted operators or `true` to require space before postfix for all unary operators
 * (i.e. increment/decrement operators).
 *
 * #### Example
 *
 * ```js
 * "requireSpaceBeforePostfixUnaryOperators": ["++", "--"]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * x = y ++; y = z --;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * x = y++; y = z--;
 * ```
 */
var assert = require('assert');
var defaultOperators = require('../utils').incrementAndDecrementOperators;
Function (anonymous_708)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_709)
✓ Was called    configure: function(operators) {···
        var isTrue = operators === true;

        assert(
            Array.isArray(operators) || isTrue,
            this.getOptionName() + ' option requires array or true value'
        );

        if (isTrue) {
            operators = defaultOperators;
        }

        this._operatorIndex = {};
        for (var i = 0, l = operators.length; i < l; i++) {
            this._operatorIndex[operators[i]] = true;
        }
    },
    configure: function(operators) {
        var isTrue = operators === true;
        assert(
Branch LogicalExpression
✓ Was returned            Array.isArray(operators) || isTrue,
✓ Was returned            Array.isArray(operators) || isTrue,
            Array.isArray(operators) || isTrue,
            this.getOptionName() + ' option requires array or true value'
        );
Branch IfStatement
✓ Positive was executed (if)        if (isTrue) {···
            operators = defaultOperators;
        }
✓ Negative was executed (else)        }···

        this._operatorIndex = {};
        if (isTrue) {
            operators = defaultOperators;
        }
        this._operatorIndex = {};
        for (var i = 0, l = operators.length; i < l; i++) {
            this._operatorIndex[operators[i]] = true;
        }
    },
Function (anonymous_710)
✓ Was called    getOptionName: function() {···
        return 'requireSpaceBeforePostfixUnaryOperators';
    },
    getOptionName: function() {
        return 'requireSpaceBeforePostfixUnaryOperators';
    },
Function (anonymous_711)
✓ Was called    check: function(file, errors) {···
        var operatorIndex = this._operatorIndex;

        // 'UpdateExpression' involve only ++ and -- operators
        file.iterateNodesByType('UpdateExpression', function(node) {
            // "!node.prefix" means postfix type of (inc|dec)rement
            if (!node.prefix && operatorIndex[node.operator]) {
                var operatorToken = file.getLastNodeToken(node);

                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(operatorToken),
                    nextToken: operatorToken,
                    message: 'Operator ' + node.operator + ' should not stick to operand'
                });
            }
        });
    }
    check: function(file, errors) {
        var operatorIndex = this._operatorIndex;
        // 'UpdateExpression' involve only ++ and -- operators
Function (anonymous_712)
✓ Was called        file.iterateNodesByType('UpdateExpression', function(node) {···
            // "!node.prefix" means postfix type of (inc|dec)rement
            if (!node.prefix && operatorIndex[node.operator]) {
                var operatorToken = file.getLastNodeToken(node);

                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(operatorToken),
                    nextToken: operatorToken,
                    message: 'Operator ' + node.operator + ' should not stick to operand'
                });
            }
        });
        file.iterateNodesByType('UpdateExpression', function(node) {
            // "!node.prefix" means postfix type of (inc|dec)rement
Branch IfStatement
✓ Positive was executed (if)            if (!node.prefix && operatorIndex[node.operator]) {···
                var operatorToken = file.getLastNodeToken(node);

                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(operatorToken),
                    nextToken: operatorToken,
                    message: 'Operator ' + node.operator + ' should not stick to operand'
                });
            }
✗ Negative was not executed (else)            }···
        });
Branch LogicalExpression
✓ Was returned            if (!node.prefix && operatorIndex[node.operator]) {
✗ Was not returned            if (!node.prefix && operatorIndex[node.operator]) {
            if (!node.prefix && operatorIndex[node.operator]) {
                var operatorToken = file.getLastNodeToken(node);
                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(operatorToken),
                    nextToken: operatorToken,
                    message: 'Operator ' + node.operator + ' should not stick to operand'
                });
            }
        });
    }
};

disallow-space-after-prefix-unary-operators.js
/**
 * Requires sticking unary operators to the right.
 *
 * Types: `Array` or `Boolean`
 *
 * Values: Array of quoted operators or `true` to disallow space after prefix for all unary operators
 *
 * #### Example
 *
 * ```js
 * "disallowSpaceAfterPrefixUnaryOperators": ["++", "--", "+", "-", "~", "!"]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * x = !y; y = ++z;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * x = ! y; y = ++ z;
 * ```
 */
var assert = require('assert');
var defaultOperators = require('../utils').unaryOperators;
Function (anonymous_713)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_714)
✓ Was called    configure: function(operators) {···
        var isTrue = operators === true;

        assert(
            Array.isArray(operators) || isTrue,
            this.getOptionName() + ' option requires array or true value'
        );

        if (isTrue) {
            operators = defaultOperators;
        }

        this._operatorIndex = {};
        for (var i = 0, l = operators.length; i < l; i++) {
            this._operatorIndex[operators[i]] = true;
        }
    },
    configure: function(operators) {
        var isTrue = operators === true;
        assert(
Branch LogicalExpression
✓ Was returned            Array.isArray(operators) || isTrue,
✓ Was returned            Array.isArray(operators) || isTrue,
            Array.isArray(operators) || isTrue,
            this.getOptionName() + ' option requires array or true value'
        );
Branch IfStatement
✓ Positive was executed (if)        if (isTrue) {···
            operators = defaultOperators;
        }
✓ Negative was executed (else)        }···

        this._operatorIndex = {};
        if (isTrue) {
            operators = defaultOperators;
        }
        this._operatorIndex = {};
        for (var i = 0, l = operators.length; i < l; i++) {
            this._operatorIndex[operators[i]] = true;
        }
    },
Function (anonymous_715)
✓ Was called    getOptionName: function() {···
        return 'disallowSpaceAfterPrefixUnaryOperators';
    },
    getOptionName: function() {
        return 'disallowSpaceAfterPrefixUnaryOperators';
    },
Function (anonymous_716)
✓ Was called    check: function(file, errors) {···
        var operatorIndex = this._operatorIndex;

        file.iterateNodesByType(['UnaryExpression', 'UpdateExpression'], function(node) {
            // Check "node.prefix" for prefix type of (inc|dec)rement
            if (node.prefix && operatorIndex[node.operator]) {
                var operatorToken = file.getFirstNodeToken(node);
                errors.assert.noWhitespaceBetween({
                    token: operatorToken,
                    nextToken: file.getNextToken(operatorToken),
                    message: 'Operator ' + node.operator + ' should stick to operand'
                });
            }
        });
    }
    check: function(file, errors) {
        var operatorIndex = this._operatorIndex;
Function (anonymous_717)
✓ Was called        file.iterateNodesByType(['UnaryExpression', 'UpdateExpression'], function(node) {···
            // Check "node.prefix" for prefix type of (inc|dec)rement
            if (node.prefix && operatorIndex[node.operator]) {
                var operatorToken = file.getFirstNodeToken(node);
                errors.assert.noWhitespaceBetween({
                    token: operatorToken,
                    nextToken: file.getNextToken(operatorToken),
                    message: 'Operator ' + node.operator + ' should stick to operand'
                });
            }
        });
        file.iterateNodesByType(['UnaryExpression', 'UpdateExpression'], function(node) {
            // Check "node.prefix" for prefix type of (inc|dec)rement
Branch IfStatement
✓ Positive was executed (if)            if (node.prefix && operatorIndex[node.operator]) {···
                var operatorToken = file.getFirstNodeToken(node);
                errors.assert.noWhitespaceBetween({
                    token: operatorToken,
                    nextToken: file.getNextToken(operatorToken),
                    message: 'Operator ' + node.operator + ' should stick to operand'
                });
            }
✓ Negative was executed (else)            }···
        });
Branch LogicalExpression
✓ Was returned            if (node.prefix && operatorIndex[node.operator]) {
✓ Was returned            if (node.prefix && operatorIndex[node.operator]) {
            if (node.prefix && operatorIndex[node.operator]) {
                var operatorToken = file.getFirstNodeToken(node);
                errors.assert.noWhitespaceBetween({
                    token: operatorToken,
                    nextToken: file.getNextToken(operatorToken),
                    message: 'Operator ' + node.operator + ' should stick to operand'
                });
            }
        });
    }
};

require-space-after-prefix-unary-operators.js
/**
 * Disallows sticking unary operators to the right.
 *
 * Types: `Array` or `Boolean`
 *
 * Values: Array of quoted operators or `true` to require space after prefix for all unary operators
 *
 * #### Example
 *
 * ```js
 * "requireSpaceAfterPrefixUnaryOperators": ["++", "--", "+", "-", "~", "!"]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * x = ! y; y = ++ z;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * x = !y; y = ++z;
 * ```
 */
var assert = require('assert');
var defaultOperators = require('../utils').unaryOperators;
Function (anonymous_718)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_719)
✓ Was called    configure: function(operators) {···
        var isTrue = operators === true;

        assert(
            Array.isArray(operators) || isTrue,
            this.getOptionName() + ' option requires array or true value'
        );

        if (isTrue) {
            operators = defaultOperators;
        }

        this._operatorIndex = {};
        for (var i = 0, l = operators.length; i < l; i++) {
            this._operatorIndex[operators[i]] = true;
        }
    },
    configure: function(operators) {
        var isTrue = operators === true;
        assert(
Branch LogicalExpression
✓ Was returned            Array.isArray(operators) || isTrue,
✓ Was returned            Array.isArray(operators) || isTrue,
            Array.isArray(operators) || isTrue,
            this.getOptionName() + ' option requires array or true value'
        );
Branch IfStatement
✓ Positive was executed (if)        if (isTrue) {···
            operators = defaultOperators;
        }
✓ Negative was executed (else)        }···

        this._operatorIndex = {};
        if (isTrue) {
            operators = defaultOperators;
        }
        this._operatorIndex = {};
        for (var i = 0, l = operators.length; i < l; i++) {
            this._operatorIndex[operators[i]] = true;
        }
    },
Function (anonymous_720)
✓ Was called    getOptionName: function() {···
        return 'requireSpaceAfterPrefixUnaryOperators';
    },
    getOptionName: function() {
        return 'requireSpaceAfterPrefixUnaryOperators';
    },
Function (anonymous_721)
✓ Was called    check: function(file, errors) {···
        var operatorIndex = this._operatorIndex;

        file.iterateNodesByType(['UnaryExpression', 'UpdateExpression'], function(node) {
            // Check "node.prefix" for prefix type of (inc|dec)rement
            if (node.prefix && operatorIndex[node.operator]) {
                var argument = node.argument.type;
                var operatorToken = file.getFirstNodeToken(node);
                var nextToken = file.getNextToken(operatorToken);

                // Do not report consecutive operators (#405)
                if (
                    argument === 'UnaryExpression' || argument === 'UpdateExpression' &&
                    nextToken.value !== '('
                ) {
                    return;
                }

                errors.assert.whitespaceBetween({
                    token: operatorToken,
                    nextToken: nextToken,
                    message: 'Operator ' + node.operator + ' should not stick to operand'
                });
            }
        });
    }
    check: function(file, errors) {
        var operatorIndex = this._operatorIndex;
Function (anonymous_722)
✓ Was called        file.iterateNodesByType(['UnaryExpression', 'UpdateExpression'], function(node) {···
            // Check "node.prefix" for prefix type of (inc|dec)rement
            if (node.prefix && operatorIndex[node.operator]) {
                var argument = node.argument.type;
                var operatorToken = file.getFirstNodeToken(node);
                var nextToken = file.getNextToken(operatorToken);

                // Do not report consecutive operators (#405)
                if (
                    argument === 'UnaryExpression' || argument === 'UpdateExpression' &&
                    nextToken.value !== '('
                ) {
                    return;
                }

                errors.assert.whitespaceBetween({
                    token: operatorToken,
                    nextToken: nextToken,
                    message: 'Operator ' + node.operator + ' should not stick to operand'
                });
            }
        });
        file.iterateNodesByType(['UnaryExpression', 'UpdateExpression'], function(node) {
            // Check "node.prefix" for prefix type of (inc|dec)rement
Branch IfStatement
✓ Positive was executed (if)            if (node.prefix && operatorIndex[node.operator]) {···
                var argument = node.argument.type;
                var operatorToken = file.getFirstNodeToken(node);
                var nextToken = file.getNextToken(operatorToken);

                // Do not report consecutive operators (#405)
                if (
                    argument === 'UnaryExpression' || argument === 'UpdateExpression' &&
                    nextToken.value !== '('
                ) {
                    return;
                }

                errors.assert.whitespaceBetween({
                    token: operatorToken,
                    nextToken: nextToken,
                    message: 'Operator ' + node.operator + ' should not stick to operand'
                });
            }
✓ Negative was executed (else)            }···
        });
Branch LogicalExpression
✓ Was returned            if (node.prefix && operatorIndex[node.operator]) {
✗ Was not returned            if (node.prefix && operatorIndex[node.operator]) {
            if (node.prefix && operatorIndex[node.operator]) {
                var argument = node.argument.type;
                var operatorToken = file.getFirstNodeToken(node);
                var nextToken = file.getNextToken(operatorToken);
                // Do not report consecutive operators (#405)
Branch IfStatement
✓ Positive was executed (if)                ) {···
                    return;
                }
✓ Negative was executed (else)                }···

                errors.assert.whitespaceBetween({
                if (
Branch LogicalExpression
✓ Was returned                    argument === 'UnaryExpression' || argument === 'UpdateExpression' &&···
                    nextToken.value !== '('
✓ Was returned                    argument === 'UnaryExpression' || argument === 'UpdateExpression' &&
Branch LogicalExpression
✓ Was returned                    nextToken.value !== '('
✓ Was returned                    argument === 'UnaryExpression' || argument === 'UpdateExpression' &&
                    argument === 'UnaryExpression' || argument === 'UpdateExpression' &&
                    nextToken.value !== '('
                ) {
                    return;
                }
                errors.assert.whitespaceBetween({
                    token: operatorToken,
                    nextToken: nextToken,
                    message: 'Operator ' + node.operator + ' should not stick to operand'
                });
            }
        });
    }
};

disallow-space-before-binary-operators.js
/**
 * Requires sticking binary operators to the left.
 *
 * Types: `Array` or `Boolean`
 *
 * Values: Array of quoted operators or `true` to disallow space before all possible binary operators
 *
 * #### Example
 *
 * ```js
 * "disallowSpaceBeforeBinaryOperators": [
 *     "=",
 *     ",",
 *     "+",
 *     "-",
 *     "/",
 *     "*",
 *     "==",
 *     "===",
 *     "!=",
 *     "!=="
 *     // etc
 * ]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * x+ y;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * x + y;
 * ```
 */
var assert = require('assert');
var allOperators = require('../utils').binaryOperators;
Function (anonymous_723)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_724)
✓ Was called    configure: function(operators) {···
        var isTrue = operators === true;

        assert(
            Array.isArray(operators) || isTrue,
            this.getOptionName() + ' option requires array or true value'
        );

        if (isTrue) {
            operators = allOperators;
        }

        this._operatorIndex = {};
        for (var i = 0, l = operators.length; i < l; i++) {
            this._operatorIndex[operators[i]] = true;
        }
    },
    configure: function(operators) {
        var isTrue = operators === true;
        assert(
Branch LogicalExpression
✓ Was returned            Array.isArray(operators) || isTrue,
✓ Was returned            Array.isArray(operators) || isTrue,
            Array.isArray(operators) || isTrue,
            this.getOptionName() + ' option requires array or true value'
        );
Branch IfStatement
✓ Positive was executed (if)        if (isTrue) {···
            operators = allOperators;
        }
✓ Negative was executed (else)        }···

        this._operatorIndex = {};
        if (isTrue) {
            operators = allOperators;
        }
        this._operatorIndex = {};
        for (var i = 0, l = operators.length; i < l; i++) {
            this._operatorIndex[operators[i]] = true;
        }
    },
Function (anonymous_725)
✓ Was called    getOptionName: function() {···
        return 'disallowSpaceBeforeBinaryOperators';
    },
    getOptionName: function() {
        return 'disallowSpaceBeforeBinaryOperators';
    },
Function (anonymous_726)
✓ Was called    check: function(file, errors) {···
        var operators = this._operatorIndex;

        // Comma
        if (operators[',']) {
            file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(token, {includeComments: true}),
                    nextToken: token,
                    message: 'Operator , should stick to previous expression'
                });
            });
        }

        // For everything else
        file.iterateNodesByType(
            ['BinaryExpression', 'AssignmentExpression', 'VariableDeclarator', 'LogicalExpression'],
            function(node) {
                var operator;
                var expression;

                if (node.type === 'VariableDeclarator') {
                    expression = node.init;
                    operator = '=';
                } else {
                    operator = node.operator;
                    expression = node.right;
                }

                if (expression === null) {
                    return;
                }

                var operatorToken = file.findPrevOperatorToken(
                    file.getFirstNodeToken(expression),
                    operator
                );

                var prevToken = file.getPrevToken(operatorToken, {includeComments: true});

                if (operators[operator]) {
                    errors.assert.noWhitespaceBetween({
                        token: prevToken,
                        nextToken: operatorToken,
                        message: 'Operator ' + node.operator + ' should stick to previous expression'
                    });
                }
            }
        );
    }
    check: function(file, errors) {
        var operators = this._operatorIndex;
        // Comma
Branch IfStatement
✓ Positive was executed (if)        if (operators[',']) {···
            file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(token, {includeComments: true}),
                    nextToken: token,
                    message: 'Operator , should stick to previous expression'
                });
            });
        }
✓ Negative was executed (else)        }···

        // For everything else
        if (operators[',']) {
Function (anonymous_727)
✓ Was called            file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {···
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(token, {includeComments: true}),
                    nextToken: token,
                    message: 'Operator , should stick to previous expression'
                });
            });
            file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(token, {includeComments: true}),
                    nextToken: token,
                    message: 'Operator , should stick to previous expression'
                });
            });
        }
        // For everything else
        file.iterateNodesByType(
            ['BinaryExpression', 'AssignmentExpression', 'VariableDeclarator', 'LogicalExpression'],
Function (anonymous_728)
✓ Was called            function(node) {···
                var operator;
                var expression;

                if (node.type === 'VariableDeclarator') {
                    expression = node.init;
                    operator = '=';
                } else {
                    operator = node.operator;
                    expression = node.right;
                }

                if (expression === null) {
                    return;
                }

                var operatorToken = file.findPrevOperatorToken(
                    file.getFirstNodeToken(expression),
                    operator
                );

                var prevToken = file.getPrevToken(operatorToken, {includeComments: true});

                if (operators[operator]) {
                    errors.assert.noWhitespaceBetween({
                        token: prevToken,
                        nextToken: operatorToken,
                        message: 'Operator ' + node.operator + ' should stick to previous expression'
                    });
                }
            }
            function(node) {
                var operator;
                var expression;
Branch IfStatement
✓ Positive was executed (if)                if (node.type === 'VariableDeclarator') {···
                    expression = node.init;
                    operator = '=';
                } else {
✓ Negative was executed (else)                } else {···
                    operator = node.operator;
                    expression = node.right;
                }
                if (node.type === 'VariableDeclarator') {
                    expression = node.init;
                    operator = '=';
                } else {
                    operator = node.operator;
                    expression = node.right;
                }
Branch IfStatement
✓ Positive was executed (if)                if (expression === null) {···
                    return;
                }
✓ Negative was executed (else)                }···

                var operatorToken = file.findPrevOperatorToken(
                if (expression === null) {
                    return;
                }
                var operatorToken = file.findPrevOperatorToken(
                    file.getFirstNodeToken(expression),
                    operator
                );
                var prevToken = file.getPrevToken(operatorToken, {includeComments: true});
Branch IfStatement
✓ Positive was executed (if)                if (operators[operator]) {···
                    errors.assert.noWhitespaceBetween({
                        token: prevToken,
                        nextToken: operatorToken,
                        message: 'Operator ' + node.operator + ' should stick to previous expression'
                    });
                }
✓ Negative was executed (else)                }···
            }
                if (operators[operator]) {
                    errors.assert.noWhitespaceBetween({
                        token: prevToken,
                        nextToken: operatorToken,
                        message: 'Operator ' + node.operator + ' should stick to previous expression'
                    });
                }
            }
        );
    }
};

require-space-before-binary-operators.js
/**
 * Disallows sticking binary operators to the left.
 *
 * Types: `Array` or `Boolean`
 *
 * Values: Array of quoted operators or `true` to require space before all possible binary operators
 * without comma operator, since it's rarely used with this rule
 *
 *
 * #### Example
 *
 * ```js
 * "requireSpaceBeforeBinaryOperators": [
 *     "=",
 *     ",",
 *     "+",
 *     "-",
 *     "/",
 *     "*",
 *     "==",
 *     "===",
 *     "!=",
 *     "!=="
 *     // etc
 * ]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * x !== y;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * x!== y;
 * ```
 */
var assert = require('assert');
var allOperators = require('../../lib/utils').binaryOperators.filter(function(operator) {
    return operator !== ',';
});
Function (anonymous_730)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_731)
✓ Was called    configure: function(operators) {···
        var isTrue = operators === true;

        assert(
            Array.isArray(operators) || isTrue,
            this.getOptionName() + ' option requires array or true value'
        );

        if (isTrue) {
            operators = allOperators;
        }

        this._operatorIndex = {};
        for (var i = 0, l = operators.length; i < l; i++) {
            this._operatorIndex[operators[i]] = true;
        }
    },
    configure: function(operators) {
        var isTrue = operators === true;
        assert(
Branch LogicalExpression
✓ Was returned            Array.isArray(operators) || isTrue,
✓ Was returned            Array.isArray(operators) || isTrue,
            Array.isArray(operators) || isTrue,
            this.getOptionName() + ' option requires array or true value'
        );
Branch IfStatement
✓ Positive was executed (if)        if (isTrue) {···
            operators = allOperators;
        }
✓ Negative was executed (else)        }···

        this._operatorIndex = {};
        if (isTrue) {
            operators = allOperators;
        }
        this._operatorIndex = {};
        for (var i = 0, l = operators.length; i < l; i++) {
            this._operatorIndex[operators[i]] = true;
        }
    },
Function (anonymous_732)
✓ Was called    getOptionName: function() {···
        return 'requireSpaceBeforeBinaryOperators';
    },
    getOptionName: function() {
        return 'requireSpaceBeforeBinaryOperators';
    },
Function (anonymous_733)
✓ Was called    check: function(file, errors) {···
        var operators = this._operatorIndex;

        // Comma
        if (operators[',']) {
            file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {
                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(token),
                    nextToken: token,
                    message: 'Operator , should not stick to preceding expression'
                });
            });
        }

        // For everything else
        file.iterateNodesByType(
            ['BinaryExpression', 'AssignmentExpression', 'VariableDeclarator', 'LogicalExpression'],
            function(node) {
                var operator;
                var expression;

                if (node.type === 'VariableDeclarator') {
                    expression = node.init;
                    operator = '=';
                } else {
                    operator = node.operator;
                    expression = node.right;
                }

                if (expression === null) {
                    return;
                }

                var operatorToken = file.findPrevOperatorToken(
                    file.getFirstNodeToken(expression),
                    operator
                );

                var prevToken = file.getPrevToken(operatorToken);

                if (operators[operator]) {
                    errors.assert.whitespaceBetween({
                        token: prevToken,
                        nextToken: operatorToken,
                        message: 'Operator ' + node.operator + ' should not stick to preceding expression'
                    });
                }
            }
        );
    }
    check: function(file, errors) {
        var operators = this._operatorIndex;
        // Comma
Branch IfStatement
✓ Positive was executed (if)        if (operators[',']) {···
            file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {
                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(token),
                    nextToken: token,
                    message: 'Operator , should not stick to preceding expression'
                });
            });
        }
✓ Negative was executed (else)        }···

        // For everything else
        if (operators[',']) {
Function (anonymous_734)
✓ Was called            file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {···
                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(token),
                    nextToken: token,
                    message: 'Operator , should not stick to preceding expression'
                });
            });
            file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {
                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(token),
                    nextToken: token,
                    message: 'Operator , should not stick to preceding expression'
                });
            });
        }
        // For everything else
        file.iterateNodesByType(
            ['BinaryExpression', 'AssignmentExpression', 'VariableDeclarator', 'LogicalExpression'],
Function (anonymous_735)
✓ Was called            function(node) {···
                var operator;
                var expression;

                if (node.type === 'VariableDeclarator') {
                    expression = node.init;
                    operator = '=';
                } else {
                    operator = node.operator;
                    expression = node.right;
                }

                if (expression === null) {
                    return;
                }

                var operatorToken = file.findPrevOperatorToken(
                    file.getFirstNodeToken(expression),
                    operator
                );

                var prevToken = file.getPrevToken(operatorToken);

                if (operators[operator]) {
                    errors.assert.whitespaceBetween({
                        token: prevToken,
                        nextToken: operatorToken,
                        message: 'Operator ' + node.operator + ' should not stick to preceding expression'
                    });
                }
            }
            function(node) {
                var operator;
                var expression;
Branch IfStatement
✓ Positive was executed (if)                if (node.type === 'VariableDeclarator') {···
                    expression = node.init;
                    operator = '=';
                } else {
✓ Negative was executed (else)                } else {···
                    operator = node.operator;
                    expression = node.right;
                }
                if (node.type === 'VariableDeclarator') {
                    expression = node.init;
                    operator = '=';
                } else {
                    operator = node.operator;
                    expression = node.right;
                }
Branch IfStatement
✓ Positive was executed (if)                if (expression === null) {···
                    return;
                }
✓ Negative was executed (else)                }···

                var operatorToken = file.findPrevOperatorToken(
                if (expression === null) {
                    return;
                }
                var operatorToken = file.findPrevOperatorToken(
                    file.getFirstNodeToken(expression),
                    operator
                );
                var prevToken = file.getPrevToken(operatorToken);
Branch IfStatement
✓ Positive was executed (if)                if (operators[operator]) {···
                    errors.assert.whitespaceBetween({
                        token: prevToken,
                        nextToken: operatorToken,
                        message: 'Operator ' + node.operator + ' should not stick to preceding expression'
                    });
                }
✓ Negative was executed (else)                }···
            }
                if (operators[operator]) {
                    errors.assert.whitespaceBetween({
                        token: prevToken,
                        nextToken: operatorToken,
                        message: 'Operator ' + node.operator + ' should not stick to preceding expression'
                    });
                }
            }
        );
    }
};

disallow-space-after-binary-operators.js
/**
 * Requires sticking binary operators to the right.
 *
 * Types: `Array` or `Boolean`
 *
 * Values: Array of quoted operators or `true` to disallow space after all possible binary operators
 *
 * #### Example
 *
 * ```js
 * "disallowSpaceAfterBinaryOperators": [
 *     "=",
 *     ",",
 *     "+",
 *     "-",
 *     "/",
 *     "*",
 *     "==",
 *     "===",
 *     "!=",
 *     "!=="
 *     // etc
 * ]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * x +y;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * x+ y;
 * ```
 */
var assert = require('assert');
var allOperators = require('../utils').binaryOperators;
Function (anonymous_736)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_737)
✓ Was called    configure: function(operators) {···
        var isTrue = operators === true;

        assert(
            Array.isArray(operators) || isTrue,
            this.getOptionName() + ' option requires array or true value'
        );

        if (isTrue) {
            operators = allOperators;
        }

        this._operatorIndex = {};
        for (var i = 0, l = operators.length; i < l; i++) {
            this._operatorIndex[operators[i]] = true;
        }
    },
    configure: function(operators) {
        var isTrue = operators === true;
        assert(
Branch LogicalExpression
✓ Was returned            Array.isArray(operators) || isTrue,
✓ Was returned            Array.isArray(operators) || isTrue,
            Array.isArray(operators) || isTrue,
            this.getOptionName() + ' option requires array or true value'
        );
Branch IfStatement
✓ Positive was executed (if)        if (isTrue) {···
            operators = allOperators;
        }
✓ Negative was executed (else)        }···

        this._operatorIndex = {};
        if (isTrue) {
            operators = allOperators;
        }
        this._operatorIndex = {};
        for (var i = 0, l = operators.length; i < l; i++) {
            this._operatorIndex[operators[i]] = true;
        }
    },
Function (anonymous_738)
✓ Was called    getOptionName: function() {···
        return 'disallowSpaceAfterBinaryOperators';
    },
    getOptionName: function() {
        return 'disallowSpaceAfterBinaryOperators';
    },
Function (anonymous_739)
✓ Was called    check: function(file, errors) {···
        var operators = this._operatorIndex;

        // Comma
        if (operators[',']) {
            file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {
                errors.assert.noWhitespaceBetween({
                    token: token,
                    nextToken: file.getNextToken(token),
                    message: 'Operator , should stick to following expression'
                });
            });
        }

        // For everything else
        file.iterateNodesByType(
            ['BinaryExpression', 'AssignmentExpression', 'VariableDeclarator', 'LogicalExpression'],
            function(node) {
                var operator;
                var expression;

                if (node.type === 'VariableDeclarator') {
                    expression = node.init;
                    operator = '=';
                } else {
                    operator = node.operator;
                    expression = node.right;
                }

                if (expression === null) {
                    return;
                }

                var operatorToken = file.findPrevOperatorToken(
                    file.getFirstNodeToken(expression),
                    operator
                );

                var nextToken = file.getNextToken(operatorToken);

                if (operators[operator]) {
                    errors.assert.noWhitespaceBetween({
                        token: operatorToken,
                        nextToken: nextToken,
                        message: 'Operator ' + operator + ' should stick to following expression'
                    });
                }
            }
        );
    }
    check: function(file, errors) {
        var operators = this._operatorIndex;
        // Comma
Branch IfStatement
✓ Positive was executed (if)        if (operators[',']) {···
            file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {
                errors.assert.noWhitespaceBetween({
                    token: token,
                    nextToken: file.getNextToken(token),
                    message: 'Operator , should stick to following expression'
                });
            });
        }
✓ Negative was executed (else)        }···

        // For everything else
        if (operators[',']) {
Function (anonymous_740)
✓ Was called            file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {···
                errors.assert.noWhitespaceBetween({
                    token: token,
                    nextToken: file.getNextToken(token),
                    message: 'Operator , should stick to following expression'
                });
            });
            file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {
                errors.assert.noWhitespaceBetween({
                    token: token,
                    nextToken: file.getNextToken(token),
                    message: 'Operator , should stick to following expression'
                });
            });
        }
        // For everything else
        file.iterateNodesByType(
            ['BinaryExpression', 'AssignmentExpression', 'VariableDeclarator', 'LogicalExpression'],
Function (anonymous_741)
✓ Was called            function(node) {···
                var operator;
                var expression;

                if (node.type === 'VariableDeclarator') {
                    expression = node.init;
                    operator = '=';
                } else {
                    operator = node.operator;
                    expression = node.right;
                }

                if (expression === null) {
                    return;
                }

                var operatorToken = file.findPrevOperatorToken(
                    file.getFirstNodeToken(expression),
                    operator
                );

                var nextToken = file.getNextToken(operatorToken);

                if (operators[operator]) {
                    errors.assert.noWhitespaceBetween({
                        token: operatorToken,
                        nextToken: nextToken,
                        message: 'Operator ' + operator + ' should stick to following expression'
                    });
                }
            }
            function(node) {
                var operator;
                var expression;
Branch IfStatement
✓ Positive was executed (if)                if (node.type === 'VariableDeclarator') {···
                    expression = node.init;
                    operator = '=';
                } else {
✓ Negative was executed (else)                } else {···
                    operator = node.operator;
                    expression = node.right;
                }
                if (node.type === 'VariableDeclarator') {
                    expression = node.init;
                    operator = '=';
                } else {
                    operator = node.operator;
                    expression = node.right;
                }
Branch IfStatement
✓ Positive was executed (if)                if (expression === null) {···
                    return;
                }
✓ Negative was executed (else)                }···

                var operatorToken = file.findPrevOperatorToken(
                if (expression === null) {
                    return;
                }
                var operatorToken = file.findPrevOperatorToken(
                    file.getFirstNodeToken(expression),
                    operator
                );
                var nextToken = file.getNextToken(operatorToken);
Branch IfStatement
✓ Positive was executed (if)                if (operators[operator]) {···
                    errors.assert.noWhitespaceBetween({
                        token: operatorToken,
                        nextToken: nextToken,
                        message: 'Operator ' + operator + ' should stick to following expression'
                    });
                }
✓ Negative was executed (else)                }···
            }
                if (operators[operator]) {
                    errors.assert.noWhitespaceBetween({
                        token: operatorToken,
                        nextToken: nextToken,
                        message: 'Operator ' + operator + ' should stick to following expression'
                    });
                }
            }
        );
    }
};

require-space-after-binary-operators.js
/**
 * Disallows sticking binary operators to the right.
 *
 * Types: `Array` or `Boolean`
 *
 * Values: Array of quoted operators or `true` to require space after all possible binary operators
 *
 * #### Example
 *
 * ```js
 * "requireSpaceAfterBinaryOperators": [
 *     "=",
 *     ",",
 *     "+",
 *     "-",
 *     "/",
 *     "*",
 *     "==",
 *     "===",
 *     "!=",
 *     "!=="
 *     // etc
 * ]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * x + y;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * x +y;
 * ```
 */
var assert = require('assert');
var allOperators = require('../utils').binaryOperators;
Function (anonymous_742)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_743)
✓ Was called    configure: function(operators) {···
        var isTrue = operators === true;

        assert(
            Array.isArray(operators) || isTrue,
            this.getOptionName() + ' option requires array or true value'
        );

        if (isTrue) {
            operators = allOperators;
        }

        this._operatorIndex = {};
        for (var i = 0, l = operators.length; i < l; i++) {
            this._operatorIndex[operators[i]] = true;
        }
    },
    configure: function(operators) {
        var isTrue = operators === true;
        assert(
Branch LogicalExpression
✗ Was not returned            Array.isArray(operators) || isTrue,
✓ Was returned            Array.isArray(operators) || isTrue,
            Array.isArray(operators) || isTrue,
            this.getOptionName() + ' option requires array or true value'
        );
Branch IfStatement
✗ Positive was not executed (if)        if (isTrue) {···
            operators = allOperators;
        }
✓ Negative was executed (else)        }···

        this._operatorIndex = {};
        if (isTrue) {
            operators = allOperators;
        }
        this._operatorIndex = {};
        for (var i = 0, l = operators.length; i < l; i++) {
            this._operatorIndex[operators[i]] = true;
        }
    },
Function (anonymous_744)
✓ Was called    getOptionName: function() {···
        return 'requireSpaceAfterBinaryOperators';
    },
    getOptionName: function() {
        return 'requireSpaceAfterBinaryOperators';
    },
Function (anonymous_745)
✓ Was called    check: function(file, errors) {···
        var operators = this._operatorIndex;

        // Comma
        if (operators[',']) {
            file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {
                errors.assert.whitespaceBetween({
                    token: token,
                    nextToken: file.getNextToken(token),
                    message: 'Operator , should not stick to following expression'
                });
            });
        }

        // For everything else
        file.iterateNodesByType(
            ['BinaryExpression', 'AssignmentExpression', 'VariableDeclarator', 'LogicalExpression'],
            function(node) {
                var operator;
                var expression;

                if (node.type === 'VariableDeclarator') {
                    expression = node.init;
                    operator = '=';
                } else {
                    operator = node.operator;
                    expression = node.right;
                }

                if (expression === null) {
                    return;
                }

                var operatorToken = file.findPrevOperatorToken(
                    file.getFirstNodeToken(expression),
                    operator
                );

                var nextToken = file.getNextToken(operatorToken);

                if (operators[operator]) {
                    errors.assert.whitespaceBetween({
                        token: operatorToken,
                        nextToken: nextToken,
                        message: 'Operator ' + operator + ' should not stick to following expression'
                    });
                }
            }
        );
    }
    check: function(file, errors) {
        var operators = this._operatorIndex;
        // Comma
Branch IfStatement
✓ Positive was executed (if)        if (operators[',']) {···
            file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {
                errors.assert.whitespaceBetween({
                    token: token,
                    nextToken: file.getNextToken(token),
                    message: 'Operator , should not stick to following expression'
                });
            });
        }
✓ Negative was executed (else)        }···

        // For everything else
        if (operators[',']) {
Function (anonymous_746)
✓ Was called            file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {···
                errors.assert.whitespaceBetween({
                    token: token,
                    nextToken: file.getNextToken(token),
                    message: 'Operator , should not stick to following expression'
                });
            });
            file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {
                errors.assert.whitespaceBetween({
                    token: token,
                    nextToken: file.getNextToken(token),
                    message: 'Operator , should not stick to following expression'
                });
            });
        }
        // For everything else
        file.iterateNodesByType(
            ['BinaryExpression', 'AssignmentExpression', 'VariableDeclarator', 'LogicalExpression'],
Function (anonymous_747)
✓ Was called            function(node) {···
                var operator;
                var expression;

                if (node.type === 'VariableDeclarator') {
                    expression = node.init;
                    operator = '=';
                } else {
                    operator = node.operator;
                    expression = node.right;
                }

                if (expression === null) {
                    return;
                }

                var operatorToken = file.findPrevOperatorToken(
                    file.getFirstNodeToken(expression),
                    operator
                );

                var nextToken = file.getNextToken(operatorToken);

                if (operators[operator]) {
                    errors.assert.whitespaceBetween({
                        token: operatorToken,
                        nextToken: nextToken,
                        message: 'Operator ' + operator + ' should not stick to following expression'
                    });
                }
            }
            function(node) {
                var operator;
                var expression;
Branch IfStatement
✓ Positive was executed (if)                if (node.type === 'VariableDeclarator') {···
                    expression = node.init;
                    operator = '=';
                } else {
✓ Negative was executed (else)                } else {···
                    operator = node.operator;
                    expression = node.right;
                }
                if (node.type === 'VariableDeclarator') {
                    expression = node.init;
                    operator = '=';
                } else {
                    operator = node.operator;
                    expression = node.right;
                }
Branch IfStatement
✓ Positive was executed (if)                if (expression === null) {···
                    return;
                }
✓ Negative was executed (else)                }···

                var operatorToken = file.findPrevOperatorToken(
                if (expression === null) {
                    return;
                }
                var operatorToken = file.findPrevOperatorToken(
                    file.getFirstNodeToken(expression),
                    operator
                );
                var nextToken = file.getNextToken(operatorToken);
Branch IfStatement
✓ Positive was executed (if)                if (operators[operator]) {···
                    errors.assert.whitespaceBetween({
                        token: operatorToken,
                        nextToken: nextToken,
                        message: 'Operator ' + operator + ' should not stick to following expression'
                    });
                }
✓ Negative was executed (else)                }···
            }
                if (operators[operator]) {
                    errors.assert.whitespaceBetween({
                        token: operatorToken,
                        nextToken: nextToken,
                        message: 'Operator ' + operator + ' should not stick to following expression'
                    });
                }
            }
        );
    }
};

require-spaces-in-conditional-expression.js
/**
 * Requires space before and/or after `?` or `:` in conditional expressions.
 *
 * Types: `Object` or `Boolean`
 *
 * Values: `"afterTest"`, `"beforeConsequent"`, `"afterConsequent"`, `"beforeAlternate"` as child properties,
 * or `true` to set all properties to `true`. Child properties must be set to `true`.
 *
 * #### Example
 *
 * ```js
 * "requireSpacesInConditionalExpression": {
 *     "afterTest": true,
 *     "beforeConsequent": true,
 *     "afterConsequent": true,
 *     "beforeAlternate": true
 * }
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var a = b ? c : d;
 * var a= b ? c : d;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var a = b? c : d;
 * var a = b ?c : d;
 * var a = b ? c: d;
 * var a = b ? c :d;
 * ```
 */
var assert = require('assert');
Function (anonymous_748)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_749)
✓ Was called    configure: function(options) {···
        var validProperties = [
            'afterTest',
            'beforeConsequent',
            'afterConsequent',
            'beforeAlternate'
        ];
        var optionName = this.getOptionName();

        if (options === true) {
            options = {
                'afterTest': true,
                'beforeConsequent': true,
                'afterConsequent': true,
                'beforeAlternate': true
            };
        }

        assert(
            typeof options === 'object',
            optionName + ' option requires a true value or an object'
        );

        var isProperlyConfigured = validProperties.some(function(key) {
            var isPresent = key in options;

            if (isPresent) {
                assert(
                    options[key] === true,
                    optionName + '.' + key + ' property requires true value or should be removed'
                );
            }

            return isPresent;
        });

        assert(
            isProperlyConfigured,
            optionName + ' must have at least 1 of the following properties: ' + validProperties.join(', ')
        );

        validProperties.forEach(function(property) {
            this['_' + property] = Boolean(options[property]);
        }.bind(this));
    },
    configure: function(options) {
        var validProperties = [
            'afterTest',
            'beforeConsequent',
            'afterConsequent',
            'beforeAlternate'
        ];
        var optionName = this.getOptionName();
Branch IfStatement
✓ Positive was executed (if)        if (options === true) {···
            options = {
                'afterTest': true,
                'beforeConsequent': true,
                'afterConsequent': true,
                'beforeAlternate': true
            };
        }
✓ Negative was executed (else)        }···

        assert(
        if (options === true) {
            options = {
                'afterTest': true,
                'beforeConsequent': true,
                'afterConsequent': true,
                'beforeAlternate': true
            };
        }
        assert(
            typeof options === 'object',
            optionName + ' option requires a true value or an object'
        );
Function (anonymous_750)
✓ Was called        var isProperlyConfigured = validProperties.some(function(key) {···
            var isPresent = key in options;

            if (isPresent) {
                assert(
                    options[key] === true,
                    optionName + '.' + key + ' property requires true value or should be removed'
                );
            }

            return isPresent;
        });
        var isProperlyConfigured = validProperties.some(function(key) {
            var isPresent = key in options;
Branch IfStatement
✓ Positive was executed (if)            if (isPresent) {···
                assert(
                    options[key] === true,
                    optionName + '.' + key + ' property requires true value or should be removed'
                );
            }
✓ Negative was executed (else)            }···

            return isPresent;
            if (isPresent) {
                assert(
                    options[key] === true,
                    optionName + '.' + key + ' property requires true value or should be removed'
                );
            }
            return isPresent;
        });
        assert(
            isProperlyConfigured,
            optionName + ' must have at least 1 of the following properties: ' + validProperties.join(', ')
        );
Function (anonymous_751)
✓ Was called        validProperties.forEach(function(property) {···
            this['_' + property] = Boolean(options[property]);
        }.bind(this));
        validProperties.forEach(function(property) {
            this['_' + property] = Boolean(options[property]);
        }.bind(this));
    },
Function (anonymous_752)
✓ Was called    getOptionName: function() {···
        return 'requireSpacesInConditionalExpression';
    },
    getOptionName: function() {
        return 'requireSpacesInConditionalExpression';
    },
Function (anonymous_753)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType(['ConditionalExpression'], function(node) {
            var consequent = node.consequent;
            var alternate = node.alternate;
            var consequentToken = file.getFirstNodeToken(consequent);
            var alternateToken = file.getFirstNodeToken(alternate);
            var questionMarkToken = file.findPrevOperatorToken(consequentToken, '?');
            var colonToken = file.findPrevOperatorToken(alternateToken, ':');
            var token;

            if (this._afterTest) {
                token = file.getPrevToken(questionMarkToken);
                errors.assert.whitespaceBetween({
                    token: token,
                    nextToken: questionMarkToken,
                    message: 'Missing space after test'
                });
            }

            if (this._beforeConsequent) {
                token = file.getNextToken(questionMarkToken);
                errors.assert.whitespaceBetween({
                    token: questionMarkToken,
                    nextToken: token,
                    message: 'Missing space before consequent'
                });
            }

            if (this._afterConsequent) {
                token = file.getPrevToken(colonToken);
                errors.assert.whitespaceBetween({
                    token: token,
                    nextToken: colonToken,
                    message: 'Missing space after consequent'
                });
            }

            if (this._beforeAlternate) {
                token = file.getNextToken(colonToken);
                errors.assert.whitespaceBetween({
                    token: colonToken,
                    nextToken: token,
                    message: 'Missing space before alternate'
                });
            }
        }.bind(this));
    }
    check: function(file, errors) {
Function (anonymous_754)
✓ Was called        file.iterateNodesByType(['ConditionalExpression'], function(node) {···
            var consequent = node.consequent;
            var alternate = node.alternate;
            var consequentToken = file.getFirstNodeToken(consequent);
            var alternateToken = file.getFirstNodeToken(alternate);
            var questionMarkToken = file.findPrevOperatorToken(consequentToken, '?');
            var colonToken = file.findPrevOperatorToken(alternateToken, ':');
            var token;

            if (this._afterTest) {
                token = file.getPrevToken(questionMarkToken);
                errors.assert.whitespaceBetween({
                    token: token,
                    nextToken: questionMarkToken,
                    message: 'Missing space after test'
                });
            }

            if (this._beforeConsequent) {
                token = file.getNextToken(questionMarkToken);
                errors.assert.whitespaceBetween({
                    token: questionMarkToken,
                    nextToken: token,
                    message: 'Missing space before consequent'
                });
            }

            if (this._afterConsequent) {
                token = file.getPrevToken(colonToken);
                errors.assert.whitespaceBetween({
                    token: token,
                    nextToken: colonToken,
                    message: 'Missing space after consequent'
                });
            }

            if (this._beforeAlternate) {
                token = file.getNextToken(colonToken);
                errors.assert.whitespaceBetween({
                    token: colonToken,
                    nextToken: token,
                    message: 'Missing space before alternate'
                });
            }
        }.bind(this));
        file.iterateNodesByType(['ConditionalExpression'], function(node) {
            var consequent = node.consequent;
            var alternate = node.alternate;
            var consequentToken = file.getFirstNodeToken(consequent);
            var alternateToken = file.getFirstNodeToken(alternate);
            var questionMarkToken = file.findPrevOperatorToken(consequentToken, '?');
            var colonToken = file.findPrevOperatorToken(alternateToken, ':');
            var token;
Branch IfStatement
✓ Positive was executed (if)            if (this._afterTest) {···
                token = file.getPrevToken(questionMarkToken);
                errors.assert.whitespaceBetween({
                    token: token,
                    nextToken: questionMarkToken,
                    message: 'Missing space after test'
                });
            }
✓ Negative was executed (else)            }···

            if (this._beforeConsequent) {
            if (this._afterTest) {
                token = file.getPrevToken(questionMarkToken);
                errors.assert.whitespaceBetween({
                    token: token,
                    nextToken: questionMarkToken,
                    message: 'Missing space after test'
                });
            }
Branch IfStatement
✓ Positive was executed (if)            if (this._beforeConsequent) {···
                token = file.getNextToken(questionMarkToken);
                errors.assert.whitespaceBetween({
                    token: questionMarkToken,
                    nextToken: token,
                    message: 'Missing space before consequent'
                });
            }
✓ Negative was executed (else)            }···

            if (this._afterConsequent) {
            if (this._beforeConsequent) {
                token = file.getNextToken(questionMarkToken);
                errors.assert.whitespaceBetween({
                    token: questionMarkToken,
                    nextToken: token,
                    message: 'Missing space before consequent'
                });
            }
Branch IfStatement
✓ Positive was executed (if)            if (this._afterConsequent) {···
                token = file.getPrevToken(colonToken);
                errors.assert.whitespaceBetween({
                    token: token,
                    nextToken: colonToken,
                    message: 'Missing space after consequent'
                });
            }
✓ Negative was executed (else)            }···

            if (this._beforeAlternate) {
            if (this._afterConsequent) {
                token = file.getPrevToken(colonToken);
                errors.assert.whitespaceBetween({
                    token: token,
                    nextToken: colonToken,
                    message: 'Missing space after consequent'
                });
            }
Branch IfStatement
✓ Positive was executed (if)            if (this._beforeAlternate) {···
                token = file.getNextToken(colonToken);
                errors.assert.whitespaceBetween({
                    token: colonToken,
                    nextToken: token,
                    message: 'Missing space before alternate'
                });
            }
✓ Negative was executed (else)            }···
        }.bind(this));
            if (this._beforeAlternate) {
                token = file.getNextToken(colonToken);
                errors.assert.whitespaceBetween({
                    token: colonToken,
                    nextToken: token,
                    message: 'Missing space before alternate'
                });
            }
        }.bind(this));
    }
};

disallow-spaces-in-conditional-expression.js
/**
 * Disallows space before and/or after `?` or `:` in conditional expressions.
 *
 * Types: `Object` or `Boolean`
 *
 * Values: `"afterTest"`, `"beforeConsequent"`, `"afterConsequent"`, `"beforeAlternate"` as child properties,
 * or `true` to set all properties to true. Child properties must be set to `true`. These token names correspond to:
 *
 * ```
 * var a = b ? c : d;
 *          ^ ^ ^ ^
 *          | | | |
 *          | | | └- beforeAlternate
 *          | | └--- afterConsequent
 *          | └-------- beforeConsequent
 *          └---------- afterTest
 * ```
 *
 * #### Example
 *
 * ```js
 * "disallowSpacesInConditionalExpression": {
 *     "afterTest": true,
 *     "beforeConsequent": true,
 *     "afterConsequent": true,
 *     "beforeAlternate": true
 * }
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var a = b?c:d;
 * var a= b?c:d;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var a = b ?c:d;
 * var a = b? c:d;
 * var a = b?c :d;
 * var a = b?c: d;
 * ```
 */
var assert = require('assert');
Function (anonymous_755)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_756)
✓ Was called    configure: function(options) {···
        var validProperties = [
            'afterTest',
            'beforeConsequent',
            'afterConsequent',
            'beforeAlternate'
        ];
        var optionName = this.getOptionName();

        if (options === true) {
            options = {
                'afterTest': true,
                'beforeConsequent': true,
                'afterConsequent': true,
                'beforeAlternate': true
            };
        }

        assert(
            typeof options === 'object',
            optionName + ' option requires a true value or an object'
        );

        var isProperlyConfigured = validProperties.some(function(key) {
            var isPresent = key in options;

            if (isPresent) {
                assert(
                    options[key] === true,
                    optionName + '.' + key + ' property requires true value or should be removed'
                );
            }

            return isPresent;
        });

        assert(
            isProperlyConfigured,
            optionName + ' must have at least 1 of the following properties: ' + validProperties.join(', ')
        );

        validProperties.forEach(function(property) {
            this['_' + property] = Boolean(options[property]);
        }.bind(this));
    },
    configure: function(options) {
        var validProperties = [
            'afterTest',
            'beforeConsequent',
            'afterConsequent',
            'beforeAlternate'
        ];
        var optionName = this.getOptionName();
Branch IfStatement
✓ Positive was executed (if)        if (options === true) {···
            options = {
                'afterTest': true,
                'beforeConsequent': true,
                'afterConsequent': true,
                'beforeAlternate': true
            };
        }
✓ Negative was executed (else)        }···

        assert(
        if (options === true) {
            options = {
                'afterTest': true,
                'beforeConsequent': true,
                'afterConsequent': true,
                'beforeAlternate': true
            };
        }
        assert(
            typeof options === 'object',
            optionName + ' option requires a true value or an object'
        );
Function (anonymous_757)
✓ Was called        var isProperlyConfigured = validProperties.some(function(key) {···
            var isPresent = key in options;

            if (isPresent) {
                assert(
                    options[key] === true,
                    optionName + '.' + key + ' property requires true value or should be removed'
                );
            }

            return isPresent;
        });
        var isProperlyConfigured = validProperties.some(function(key) {
            var isPresent = key in options;
Branch IfStatement
✓ Positive was executed (if)            if (isPresent) {···
                assert(
                    options[key] === true,
                    optionName + '.' + key + ' property requires true value or should be removed'
                );
            }
✓ Negative was executed (else)            }···

            return isPresent;
            if (isPresent) {
                assert(
                    options[key] === true,
                    optionName + '.' + key + ' property requires true value or should be removed'
                );
            }
            return isPresent;
        });
        assert(
            isProperlyConfigured,
            optionName + ' must have at least 1 of the following properties: ' + validProperties.join(', ')
        );
Function (anonymous_758)
✓ Was called        validProperties.forEach(function(property) {···
            this['_' + property] = Boolean(options[property]);
        }.bind(this));
        validProperties.forEach(function(property) {
            this['_' + property] = Boolean(options[property]);
        }.bind(this));
    },
Function (anonymous_759)
✓ Was called    getOptionName: function() {···
        return 'disallowSpacesInConditionalExpression';
    },
    getOptionName: function() {
        return 'disallowSpacesInConditionalExpression';
    },
Function (anonymous_760)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType(['ConditionalExpression'], function(node) {

            var test = node.test;
            var consequent = node.consequent;
            var consequentToken = file.getFirstNodeToken(consequent);
            var alternate = node.alternate;
            var alternateToken = file.getFirstNodeToken(alternate);
            var questionMarkToken = file.findPrevOperatorToken(consequentToken, '?');
            var colonToken = file.findPrevOperatorToken(alternateToken, ':');
            var token;

            if (this._afterTest && test.loc.end.line === questionMarkToken.loc.start.line) {
                token = file.getPrevToken(questionMarkToken);

                errors.assert.noWhitespaceBetween({
                    token: token,
                    nextToken: questionMarkToken,
                    message: 'Illegal space after test'
                });
            }

            if (this._beforeConsequent && consequent.loc.end.line === questionMarkToken.loc.start.line) {
                token = file.getNextToken(questionMarkToken);

                errors.assert.noWhitespaceBetween({
                    token: questionMarkToken,
                    nextToken: token,
                    message: 'Illegal space before consequent'
                });
            }

            if (this._afterConsequent && consequent.loc.end.line === colonToken.loc.start.line) {
                token = file.getPrevToken(colonToken);

                errors.assert.noWhitespaceBetween({
                    token: token,
                    nextToken: colonToken,
                    message: 'Illegal space after consequent'
                });
            }

            if (this._beforeAlternate && alternate.loc.end.line === colonToken.loc.start.line) {
                token = file.getNextToken(colonToken);
                errors.assert.noWhitespaceBetween({
                    token: colonToken,
                    nextToken: token,
                    message: 'Illegal space before alternate'
                });
            }
        }.bind(this));
    }
    check: function(file, errors) {
Function (anonymous_761)
✓ Was called        file.iterateNodesByType(['ConditionalExpression'], function(node) {···

            var test = node.test;
            var consequent = node.consequent;
            var consequentToken = file.getFirstNodeToken(consequent);
            var alternate = node.alternate;
            var alternateToken = file.getFirstNodeToken(alternate);
            var questionMarkToken = file.findPrevOperatorToken(consequentToken, '?');
            var colonToken = file.findPrevOperatorToken(alternateToken, ':');
            var token;

            if (this._afterTest && test.loc.end.line === questionMarkToken.loc.start.line) {
                token = file.getPrevToken(questionMarkToken);

                errors.assert.noWhitespaceBetween({
                    token: token,
                    nextToken: questionMarkToken,
                    message: 'Illegal space after test'
                });
            }

            if (this._beforeConsequent && consequent.loc.end.line === questionMarkToken.loc.start.line) {
                token = file.getNextToken(questionMarkToken);

                errors.assert.noWhitespaceBetween({
                    token: questionMarkToken,
                    nextToken: token,
                    message: 'Illegal space before consequent'
                });
            }

            if (this._afterConsequent && consequent.loc.end.line === colonToken.loc.start.line) {
                token = file.getPrevToken(colonToken);

                errors.assert.noWhitespaceBetween({
                    token: token,
                    nextToken: colonToken,
                    message: 'Illegal space after consequent'
                });
            }

            if (this._beforeAlternate && alternate.loc.end.line === colonToken.loc.start.line) {
                token = file.getNextToken(colonToken);
                errors.assert.noWhitespaceBetween({
                    token: colonToken,
                    nextToken: token,
                    message: 'Illegal space before alternate'
                });
            }
        }.bind(this));
        file.iterateNodesByType(['ConditionalExpression'], function(node) {
            var test = node.test;
            var consequent = node.consequent;
            var consequentToken = file.getFirstNodeToken(consequent);
            var alternate = node.alternate;
            var alternateToken = file.getFirstNodeToken(alternate);
            var questionMarkToken = file.findPrevOperatorToken(consequentToken, '?');
            var colonToken = file.findPrevOperatorToken(alternateToken, ':');
            var token;
Branch IfStatement
✓ Positive was executed (if)            if (this._afterTest && test.loc.end.line === questionMarkToken.loc.start.line) {···
                token = file.getPrevToken(questionMarkToken);

                errors.assert.noWhitespaceBetween({
                    token: token,
                    nextToken: questionMarkToken,
                    message: 'Illegal space after test'
                });
            }
✓ Negative was executed (else)            }···

            if (this._beforeConsequent && consequent.loc.end.line === questionMarkToken.loc.start.line) {
Branch LogicalExpression
✓ Was returned            if (this._afterTest && test.loc.end.line === questionMarkToken.loc.start.line) {
✓ Was returned            if (this._afterTest && test.loc.end.line === questionMarkToken.loc.start.line) {
            if (this._afterTest && test.loc.end.line === questionMarkToken.loc.start.line) {
                token = file.getPrevToken(questionMarkToken);
                errors.assert.noWhitespaceBetween({
                    token: token,
                    nextToken: questionMarkToken,
                    message: 'Illegal space after test'
                });
            }
Branch IfStatement
✓ Positive was executed (if)            if (this._beforeConsequent && consequent.loc.end.line === questionMarkToken.loc.start.line) {···
                token = file.getNextToken(questionMarkToken);

                errors.assert.noWhitespaceBetween({
                    token: questionMarkToken,
                    nextToken: token,
                    message: 'Illegal space before consequent'
                });
            }
✓ Negative was executed (else)            }···

            if (this._afterConsequent && consequent.loc.end.line === colonToken.loc.start.line) {
Branch LogicalExpression
✓ Was returned            if (this._beforeConsequent && consequent.loc.end.line === questionMarkToken.loc.start.line) {
✓ Was returned            if (this._beforeConsequent && consequent.loc.end.line === questionMarkToken.loc.start.line) {
            if (this._beforeConsequent && consequent.loc.end.line === questionMarkToken.loc.start.line) {
                token = file.getNextToken(questionMarkToken);
                errors.assert.noWhitespaceBetween({
                    token: questionMarkToken,
                    nextToken: token,
                    message: 'Illegal space before consequent'
                });
            }
Branch IfStatement
✓ Positive was executed (if)            if (this._afterConsequent && consequent.loc.end.line === colonToken.loc.start.line) {···
                token = file.getPrevToken(colonToken);

                errors.assert.noWhitespaceBetween({
                    token: token,
                    nextToken: colonToken,
                    message: 'Illegal space after consequent'
                });
            }
✓ Negative was executed (else)            }···

            if (this._beforeAlternate && alternate.loc.end.line === colonToken.loc.start.line) {
Branch LogicalExpression
✓ Was returned            if (this._afterConsequent && consequent.loc.end.line === colonToken.loc.start.line) {
✓ Was returned            if (this._afterConsequent && consequent.loc.end.line === colonToken.loc.start.line) {
            if (this._afterConsequent && consequent.loc.end.line === colonToken.loc.start.line) {
                token = file.getPrevToken(colonToken);
                errors.assert.noWhitespaceBetween({
                    token: token,
                    nextToken: colonToken,
                    message: 'Illegal space after consequent'
                });
            }
Branch IfStatement
✓ Positive was executed (if)            if (this._beforeAlternate && alternate.loc.end.line === colonToken.loc.start.line) {···
                token = file.getNextToken(colonToken);
                errors.assert.noWhitespaceBetween({
                    token: colonToken,
                    nextToken: token,
                    message: 'Illegal space before alternate'
                });
            }
✓ Negative was executed (else)            }···
        }.bind(this));
Branch LogicalExpression
✓ Was returned            if (this._beforeAlternate && alternate.loc.end.line === colonToken.loc.start.line) {
✓ Was returned            if (this._beforeAlternate && alternate.loc.end.line === colonToken.loc.start.line) {
            if (this._beforeAlternate && alternate.loc.end.line === colonToken.loc.start.line) {
                token = file.getNextToken(colonToken);
                errors.assert.noWhitespaceBetween({
                    token: colonToken,
                    nextToken: token,
                    message: 'Illegal space before alternate'
                });
            }
        }.bind(this));
    }
};

require-spaces-in-function.js
/**
 * Expression
 *
 * Requires space before `()` or `{}` in function expressions (both [named](#requirespacesinnamedfunctionexpression)
 * and [anonymous](#requirespacesinanonymousfunctionexpression)) and function declarations.
 *
 * Type: `Object`
 *
 * Values: `"beforeOpeningRoundBrace"` and `"beforeOpeningCurlyBrace"` as child properties.
 * Child properties must be set to `true`.
 *
 * #### Example
 *
 * ```js
 * "requireSpacesInFunction": {
 *     "beforeOpeningRoundBrace": true,
 *     "beforeOpeningCurlyBrace": true
 * }
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var x = function () {};
 * var x = function a () {};
 * function a () {}
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = function() {};
 * var x = function (){};
 * var x = function(){};
 * var x = function a() {};
 * var x = function a (){};
 * var x = function a(){};
 * function a() {}
 * function a (){}
 * function a(){}
 * ```
 */
var assert = require('assert');
Function (anonymous_762)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_763)
✓ Was called    configure: function(options) {···
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );

        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }

        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }

        assert(
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace or beforeOpeningRoundBrace property'
        );

        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
    configure: function(options) {
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningRoundBrace' in options) {···
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        if ('beforeOpeningCurlyBrace' in options) {
        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningCurlyBrace' in options) {···
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        assert(
        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
        assert(
Branch LogicalExpression
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace or beforeOpeningRoundBrace property'
        );
        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
Function (anonymous_764)
✓ Was called    getOptionName: function() {···
        return 'requireSpacesInFunction';
    },
    getOptionName: function() {
        return 'requireSpacesInFunction';
    },
Function (anonymous_765)
✓ Was called    check: function(file, errors) {···
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;

        file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {
            var parent = node.parentNode;

            // Ignore syntactic sugar for getters and setters.
            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
                return;
            }

            if (beforeOpeningRoundBrace) {
                // for a named function, use node.id
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.whitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Missing space before opening round brace',
                });
            }

            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Missing space before opening curly brace',
                });
            }
        });
    }
    check: function(file, errors) {
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;
Function (anonymous_766)
✓ Was called        file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {···
            var parent = node.parentNode;

            // Ignore syntactic sugar for getters and setters.
            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
                return;
            }

            if (beforeOpeningRoundBrace) {
                // for a named function, use node.id
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.whitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Missing space before opening round brace',
                });
            }

            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Missing space before opening curly brace',
                });
            }
        });
        file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {
            var parent = node.parentNode;
            // Ignore syntactic sugar for getters and setters.
Branch IfStatement
✓ Positive was executed (if)            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {···
                return;
            }
✓ Negative was executed (else)            }···

            if (beforeOpeningRoundBrace) {
Branch LogicalExpression
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
Branch LogicalExpression
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (beforeOpeningRoundBrace) {···
                // for a named function, use node.id
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.whitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Missing space before opening round brace',
                });
            }
✓ Negative was executed (else)            }···

            if (beforeOpeningCurlyBrace) {
            if (beforeOpeningRoundBrace) {
                // for a named function, use node.id
Branch LogicalExpression
✓ Was returned                var functionToken = file.getFirstNodeToken(node.id || node);
✓ Was returned                var functionToken = file.getFirstNodeToken(node.id || node);
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.whitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Missing space before opening round brace',
                });
            }
Branch IfStatement
✓ Positive was executed (if)            if (beforeOpeningCurlyBrace) {···
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Missing space before opening curly brace',
                });
            }
✓ Negative was executed (else)            }···
        });
            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Missing space before opening curly brace',
                });
            }
        });
    }
};

disallow-spaces-in-function.js
/**
 * Expression
 *
 * Disallows space before `()` or `{}` in function expressions (both [named](#disallowspacesinnamedfunctionexpression)
 * and [anonymous](#disallowspacesinanonymousfunctionexpression)) and function declarations.
 *
 * Type: `Object`
 *
 * Values: `"beforeOpeningRoundBrace"` and `"beforeOpeningCurlyBrace"` as child properties.
 * Child properties must be set to `true`.
 *
 * #### Example
 *
 * ```js
 * "disallowSpacesInFunction": {
 *     "beforeOpeningRoundBrace": true,
 *     "beforeOpeningCurlyBrace": true
 * }
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var x = function(){};
 * var x = function a(){};
 * function a(){}
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = function() {};
 * var x = function (){};
 * var x = function () {};
 * var x = function a() {};
 * var x = function a (){};
 * var x = function a () {};
 * function a() {}
 * function a (){}
 * function a () {}
 * ```
 */
var assert = require('assert');
Function (anonymous_767)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_768)
✓ Was called    configure: function(options) {···
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );

        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }

        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }

        assert(
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace or beforeOpeningRoundBrace property'
        );

        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
    configure: function(options) {
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningRoundBrace' in options) {···
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        if ('beforeOpeningCurlyBrace' in options) {
        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningCurlyBrace' in options) {···
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        assert(
        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
        assert(
Branch LogicalExpression
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace or beforeOpeningRoundBrace property'
        );
        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
Function (anonymous_769)
✓ Was called    getOptionName: function() {···
        return 'disallowSpacesInFunction';
    },
    getOptionName: function() {
        return 'disallowSpacesInFunction';
    },
Function (anonymous_770)
✓ Was called    check: function(file, errors) {···
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;

        file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {
            var parent = node.parentNode;

            // Ignore syntactic sugar for getters and setters.
            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
                return;
            }

            if (beforeOpeningRoundBrace) {
                // for a named function, use node.id
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.noWhitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Illegal space before opening round brace',
                });
            }

            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Illegal space before opening curly brace',
                });
            }
        });
    }
    check: function(file, errors) {
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;
Function (anonymous_771)
✓ Was called        file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {···
            var parent = node.parentNode;

            // Ignore syntactic sugar for getters and setters.
            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
                return;
            }

            if (beforeOpeningRoundBrace) {
                // for a named function, use node.id
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.noWhitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Illegal space before opening round brace',
                });
            }

            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Illegal space before opening curly brace',
                });
            }
        });
        file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {
            var parent = node.parentNode;
            // Ignore syntactic sugar for getters and setters.
Branch IfStatement
✓ Positive was executed (if)            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {···
                return;
            }
✓ Negative was executed (else)            }···

            if (beforeOpeningRoundBrace) {
Branch LogicalExpression
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
Branch LogicalExpression
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (beforeOpeningRoundBrace) {···
                // for a named function, use node.id
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.noWhitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Illegal space before opening round brace',
                });
            }
✓ Negative was executed (else)            }···

            if (beforeOpeningCurlyBrace) {
            if (beforeOpeningRoundBrace) {
                // for a named function, use node.id
Branch LogicalExpression
✓ Was returned                var functionToken = file.getFirstNodeToken(node.id || node);
✓ Was returned                var functionToken = file.getFirstNodeToken(node.id || node);
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.noWhitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Illegal space before opening round brace',
                });
            }
Branch IfStatement
✓ Positive was executed (if)            if (beforeOpeningCurlyBrace) {···
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Illegal space before opening curly brace',
                });
            }
✓ Negative was executed (else)            }···
        });
            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Illegal space before opening curly brace',
                });
            }
        });
    }
};

require-spaces-in-function-expression.js
/**
 * Requires space before `()` or `{}` in function expressions (both [named](#requirespacesinnamedfunctionexpression)
 * and [anonymous](#requirespacesinanonymousfunctionexpression)).
 *
 * Type: `Object`
 *
 * Values: `"beforeOpeningRoundBrace"` and `"beforeOpeningCurlyBrace"` as child properties.
 * Child properties must be set to `true`.
 *
 * #### Example
 *
 * ```js
 * "requireSpacesInFunctionExpression": {
 *     "beforeOpeningRoundBrace": true,
 *     "beforeOpeningCurlyBrace": true
 * }
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var x = function () {};
 * var x = function a () {};
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = function() {};
 * var x = function (){};
 * var x = function(){};
 * var x = function a() {};
 * var x = function a (){};
 * var x = function a(){};
 * ```
 */
var assert = require('assert');
Function (anonymous_772)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_773)
✓ Was called    configure: function(options) {···
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );

        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }

        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }

        assert(
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace or beforeOpeningRoundBrace property'
        );

        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
    configure: function(options) {
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningRoundBrace' in options) {···
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        if ('beforeOpeningCurlyBrace' in options) {
        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningCurlyBrace' in options) {···
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        assert(
        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
        assert(
Branch LogicalExpression
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace or beforeOpeningRoundBrace property'
        );
        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
Function (anonymous_774)
✓ Was called    getOptionName: function() {···
        return 'requireSpacesInFunctionExpression';
    },
    getOptionName: function() {
        return 'requireSpacesInFunctionExpression';
    },
Function (anonymous_775)
✓ Was called    check: function(file, errors) {···
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;

        file.iterateNodesByType('FunctionExpression', function(node) {
            var parent = node.parentNode;

            // Ignore syntactic sugar for getters and setters.
            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
                return;
            }

            if (beforeOpeningRoundBrace) {
                // for a named function, use node.id
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.whitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Missing space before opening round brace',
                });
            }

            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Missing space before opening curly brace',
                });
            }
        });
    }
    check: function(file, errors) {
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;
Function (anonymous_776)
✓ Was called        file.iterateNodesByType('FunctionExpression', function(node) {···
            var parent = node.parentNode;

            // Ignore syntactic sugar for getters and setters.
            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
                return;
            }

            if (beforeOpeningRoundBrace) {
                // for a named function, use node.id
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.whitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Missing space before opening round brace',
                });
            }

            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Missing space before opening curly brace',
                });
            }
        });
        file.iterateNodesByType('FunctionExpression', function(node) {
            var parent = node.parentNode;
            // Ignore syntactic sugar for getters and setters.
Branch IfStatement
✓ Positive was executed (if)            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {···
                return;
            }
✓ Negative was executed (else)            }···

            if (beforeOpeningRoundBrace) {
Branch LogicalExpression
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
Branch LogicalExpression
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (beforeOpeningRoundBrace) {···
                // for a named function, use node.id
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.whitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Missing space before opening round brace',
                });
            }
✓ Negative was executed (else)            }···

            if (beforeOpeningCurlyBrace) {
            if (beforeOpeningRoundBrace) {
                // for a named function, use node.id
Branch LogicalExpression
✓ Was returned                var functionToken = file.getFirstNodeToken(node.id || node);
✓ Was returned                var functionToken = file.getFirstNodeToken(node.id || node);
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.whitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Missing space before opening round brace',
                });
            }
Branch IfStatement
✓ Positive was executed (if)            if (beforeOpeningCurlyBrace) {···
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Missing space before opening curly brace',
                });
            }
✓ Negative was executed (else)            }···
        });
            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Missing space before opening curly brace',
                });
            }
        });
    }
};

disallow-spaces-in-function-expression.js
/**
 * Disallows space before `()` or `{}` in function expressions (both [named](#disallowspacesinnamedfunctionexpression)
 * and [anonymous](#disallowspacesinanonymousfunctionexpression)).
 *
 * Type: `Object`
 *
 * Values: `"beforeOpeningRoundBrace"` and `"beforeOpeningCurlyBrace"` as child properties.
 * Child properties must be set to `true`.
 *
 * #### Example
 *
 * ```js
 * "disallowSpacesInFunctionExpression": {
 *     "beforeOpeningRoundBrace": true,
 *     "beforeOpeningCurlyBrace": true
 * }
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var x = function(){};
 * var x = function a(){};
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = function() {};
 * var x = function (){};
 * var x = function () {};
 * var x = function a() {};
 * var x = function a (){};
 * var x = function a () {};
 * ```
 */
var assert = require('assert');
Function (anonymous_777)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_778)
✓ Was called    configure: function(options) {···
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );

        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }

        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }

        assert(
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace or beforeOpeningRoundBrace property'
        );

        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
    configure: function(options) {
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningRoundBrace' in options) {···
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        if ('beforeOpeningCurlyBrace' in options) {
        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningCurlyBrace' in options) {···
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        assert(
        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
        assert(
Branch LogicalExpression
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace or beforeOpeningRoundBrace property'
        );
        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
Function (anonymous_779)
✓ Was called    getOptionName: function() {···
        return 'disallowSpacesInFunctionExpression';
    },
    getOptionName: function() {
        return 'disallowSpacesInFunctionExpression';
    },
Function (anonymous_780)
✓ Was called    check: function(file, errors) {···
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;

        file.iterateNodesByType('FunctionExpression', function(node) {
            var parent = node.parentNode;

            // Ignore syntactic sugar for getters and setters.
            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
                return;
            }

            if (beforeOpeningRoundBrace) {
                // for a named function, use node.id
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.noWhitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Illegal space before opening round brace',
                });
            }

            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Illegal space before opening curly brace',
                });
            }
        });
    }
    check: function(file, errors) {
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;
Function (anonymous_781)
✓ Was called        file.iterateNodesByType('FunctionExpression', function(node) {···
            var parent = node.parentNode;

            // Ignore syntactic sugar for getters and setters.
            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
                return;
            }

            if (beforeOpeningRoundBrace) {
                // for a named function, use node.id
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.noWhitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Illegal space before opening round brace',
                });
            }

            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Illegal space before opening curly brace',
                });
            }
        });
        file.iterateNodesByType('FunctionExpression', function(node) {
            var parent = node.parentNode;
            // Ignore syntactic sugar for getters and setters.
Branch IfStatement
✓ Positive was executed (if)            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {···
                return;
            }
✓ Negative was executed (else)            }···

            if (beforeOpeningRoundBrace) {
Branch LogicalExpression
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
Branch LogicalExpression
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (beforeOpeningRoundBrace) {···
                // for a named function, use node.id
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.noWhitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Illegal space before opening round brace',
                });
            }
✓ Negative was executed (else)            }···

            if (beforeOpeningCurlyBrace) {
            if (beforeOpeningRoundBrace) {
                // for a named function, use node.id
Branch LogicalExpression
✓ Was returned                var functionToken = file.getFirstNodeToken(node.id || node);
✓ Was returned                var functionToken = file.getFirstNodeToken(node.id || node);
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.noWhitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Illegal space before opening round brace',
                });
            }
Branch IfStatement
✓ Positive was executed (if)            if (beforeOpeningCurlyBrace) {···
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Illegal space before opening curly brace',
                });
            }
✓ Negative was executed (else)            }···
        });
            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Illegal space before opening curly brace',
                });
            }
        });
    }
};

require-spaces-in-anonymous-function-expression.js
/**
 * Requires space before `()` or `{}` in anonymous function expressions.
 *
 * Type: `Object`
 *
 * Values: `"beforeOpeningRoundBrace"` and `"beforeOpeningCurlyBrace"` as child properties.
 * Child properties must be set to `true`.
 *
 * #### Example
 *
 * ```js
 * "requireSpacesInAnonymousFunctionExpression": {
 *     "beforeOpeningRoundBrace": true,
 *     "beforeOpeningCurlyBrace": true
 * }
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var foo = function () {};
 * var Foo = {
 *     foo: function () {};
 * }
 * array.map(function () {});
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var foo = function() {};
 * var Foo = {
 *     foo: function (){};
 * }
 * array.map(function(){});
 * ```
 */
var assert = require('assert');
Function (anonymous_782)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_783)
✓ Was called    configure: function(options) {···
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );

        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }

        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }

        assert(
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace ' +
            ' or beforeOpeningRoundBrace property'
        );

        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
    configure: function(options) {
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningRoundBrace' in options) {···
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        if ('beforeOpeningCurlyBrace' in options) {
        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningCurlyBrace' in options) {···
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        assert(
        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
        assert(
Branch LogicalExpression
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace ' +
            ' or beforeOpeningRoundBrace property'
        );
        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
Function (anonymous_784)
✓ Was called    getOptionName: function() {···
        return 'requireSpacesInAnonymousFunctionExpression';
    },
    getOptionName: function() {
        return 'requireSpacesInAnonymousFunctionExpression';
    },
Function (anonymous_785)
✓ Was called    check: function(file, errors) {···
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;

        file.iterateNodesByType(['FunctionExpression'], function(node) {
            var parent = node.parentNode;

            // Ignore syntactic sugar for getters and setters.
            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
                return;
            }

            if (!node.id) {

                if (beforeOpeningRoundBrace) {
                    var functionToken = file.getFirstNodeToken(node);
                    errors.assert.whitespaceBetween({
                        token: functionToken,
                        nextToken: file.getNextToken(functionToken),
                        message: 'Missing space before opening round brace'
                    });
                }

                if (beforeOpeningCurlyBrace) {
                    var bodyToken = file.getFirstNodeToken(node.body);
                    errors.assert.whitespaceBetween({
                        token: file.getPrevToken(bodyToken),
                        nextToken: bodyToken,
                        message: 'Missing space before opening curly brace'
                    });
                }
            }
        });
    }
    check: function(file, errors) {
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;
Function (anonymous_786)
✓ Was called        file.iterateNodesByType(['FunctionExpression'], function(node) {···
            var parent = node.parentNode;

            // Ignore syntactic sugar for getters and setters.
            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
                return;
            }

            if (!node.id) {

                if (beforeOpeningRoundBrace) {
                    var functionToken = file.getFirstNodeToken(node);
                    errors.assert.whitespaceBetween({
                        token: functionToken,
                        nextToken: file.getNextToken(functionToken),
                        message: 'Missing space before opening round brace'
                    });
                }

                if (beforeOpeningCurlyBrace) {
                    var bodyToken = file.getFirstNodeToken(node.body);
                    errors.assert.whitespaceBetween({
                        token: file.getPrevToken(bodyToken),
                        nextToken: bodyToken,
                        message: 'Missing space before opening curly brace'
                    });
                }
            }
        });
        file.iterateNodesByType(['FunctionExpression'], function(node) {
            var parent = node.parentNode;
            // Ignore syntactic sugar for getters and setters.
Branch IfStatement
✓ Positive was executed (if)            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {···
                return;
            }
✓ Negative was executed (else)            }···

            if (!node.id) {
Branch LogicalExpression
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
Branch LogicalExpression
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (!node.id) {···

                if (beforeOpeningRoundBrace) {
                    var functionToken = file.getFirstNodeToken(node);
                    errors.assert.whitespaceBetween({
                        token: functionToken,
                        nextToken: file.getNextToken(functionToken),
                        message: 'Missing space before opening round brace'
                    });
                }

                if (beforeOpeningCurlyBrace) {
                    var bodyToken = file.getFirstNodeToken(node.body);
                    errors.assert.whitespaceBetween({
                        token: file.getPrevToken(bodyToken),
                        nextToken: bodyToken,
                        message: 'Missing space before opening curly brace'
                    });
                }
            }
✗ Negative was not executed (else)            }···
        });
            if (!node.id) {
Branch IfStatement
✓ Positive was executed (if)                if (beforeOpeningRoundBrace) {···
                    var functionToken = file.getFirstNodeToken(node);
                    errors.assert.whitespaceBetween({
                        token: functionToken,
                        nextToken: file.getNextToken(functionToken),
                        message: 'Missing space before opening round brace'
                    });
                }
✓ Negative was executed (else)                }···

                if (beforeOpeningCurlyBrace) {
                if (beforeOpeningRoundBrace) {
                    var functionToken = file.getFirstNodeToken(node);
                    errors.assert.whitespaceBetween({
                        token: functionToken,
                        nextToken: file.getNextToken(functionToken),
                        message: 'Missing space before opening round brace'
                    });
                }
Branch IfStatement
✓ Positive was executed (if)                if (beforeOpeningCurlyBrace) {···
                    var bodyToken = file.getFirstNodeToken(node.body);
                    errors.assert.whitespaceBetween({
                        token: file.getPrevToken(bodyToken),
                        nextToken: bodyToken,
                        message: 'Missing space before opening curly brace'
                    });
                }
✓ Negative was executed (else)                }···
            }
                if (beforeOpeningCurlyBrace) {
                    var bodyToken = file.getFirstNodeToken(node.body);
                    errors.assert.whitespaceBetween({
                        token: file.getPrevToken(bodyToken),
                        nextToken: bodyToken,
                        message: 'Missing space before opening curly brace'
                    });
                }
            }
        });
    }
};

disallow-spaces-in-anonymous-function-expression.js
/**
 * Disallows space before `()` or `{}` in anonymous function expressions.
 *
 * Type: `Object`
 *
 * Values: `"beforeOpeningRoundBrace"` and `"beforeOpeningCurlyBrace"` as child properties.
 * Child properties must be set to `true`.
 *
 * #### Example
 *
 * ```js
 * "disallowSpacesInAnonymousFunctionExpression": {
 *     "beforeOpeningRoundBrace": true,
 *     "beforeOpeningCurlyBrace": true
 * }
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var foo = function(){};
 * var Foo = {
 *     foo: function(){};
 * }
 * array.map(function(){});
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var foo = function () {};
 * var Foo = {
 *     foo: function (){};
 * }
 * array.map(function() {});
 * ```
 */
var assert = require('assert');
Function (anonymous_787)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_788)
✓ Was called    configure: function(options) {···
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );

        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }

        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }

        assert(
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace ' +
            ' or beforeOpeningRoundBrace property'
        );

        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
    configure: function(options) {
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningRoundBrace' in options) {···
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        if ('beforeOpeningCurlyBrace' in options) {
        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningCurlyBrace' in options) {···
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        assert(
        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
        assert(
Branch LogicalExpression
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace ' +
            ' or beforeOpeningRoundBrace property'
        );
        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
Function (anonymous_789)
✓ Was called    getOptionName: function() {···
        return 'disallowSpacesInAnonymousFunctionExpression';
    },
    getOptionName: function() {
        return 'disallowSpacesInAnonymousFunctionExpression';
    },
Function (anonymous_790)
✓ Was called    check: function(file, errors) {···
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;

        file.iterateNodesByType(['FunctionExpression'], function(node) {
            var parent = node.parentNode;

            // Ignore syntactic sugar for getters and setters.
            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
                return;
            }

            // anonymous function expressions only
            if (node.id) {
                return;
            }

            if (beforeOpeningRoundBrace) {
                var functionToken = file.getFirstNodeToken(node);
                errors.assert.noWhitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Illegal space before opening round brace',
                });
            }

            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Illegal space before opening curly brace',
                });
            }
        });
    }
    check: function(file, errors) {
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;
Function (anonymous_791)
✓ Was called        file.iterateNodesByType(['FunctionExpression'], function(node) {···
            var parent = node.parentNode;

            // Ignore syntactic sugar for getters and setters.
            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
                return;
            }

            // anonymous function expressions only
            if (node.id) {
                return;
            }

            if (beforeOpeningRoundBrace) {
                var functionToken = file.getFirstNodeToken(node);
                errors.assert.noWhitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Illegal space before opening round brace',
                });
            }

            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Illegal space before opening curly brace',
                });
            }
        });
        file.iterateNodesByType(['FunctionExpression'], function(node) {
            var parent = node.parentNode;
            // Ignore syntactic sugar for getters and setters.
Branch IfStatement
✓ Positive was executed (if)            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {···
                return;
            }
✓ Negative was executed (else)            }···

            // anonymous function expressions only
Branch LogicalExpression
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
Branch LogicalExpression
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
✓ Was returned            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
                return;
            }
            // anonymous function expressions only
Branch IfStatement
✓ Positive was executed (if)            if (node.id) {···
                return;
            }
✓ Negative was executed (else)            }···

            if (beforeOpeningRoundBrace) {
            if (node.id) {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (beforeOpeningRoundBrace) {···
                var functionToken = file.getFirstNodeToken(node);
                errors.assert.noWhitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Illegal space before opening round brace',
                });
            }
✓ Negative was executed (else)            }···

            if (beforeOpeningCurlyBrace) {
            if (beforeOpeningRoundBrace) {
                var functionToken = file.getFirstNodeToken(node);
                errors.assert.noWhitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Illegal space before opening round brace',
                });
            }
Branch IfStatement
✓ Positive was executed (if)            if (beforeOpeningCurlyBrace) {···
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Illegal space before opening curly brace',
                });
            }
✓ Negative was executed (else)            }···
        });
            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Illegal space before opening curly brace',
                });
            }
        });
    }
};

require-spaces-in-named-function-expression.js
/**
 * Requires space before `()` or `{}` in named function expressions.
 *
 * Type: `Object`
 *
 * Values: `"beforeOpeningRoundBrace"` and `"beforeOpeningCurlyBrace"` as child properties.
 * Child properties must be set to `true`.
 *
 * #### Example
 *
 * ```js
 * "requireSpacesInNamedFunctionExpression": {
 *     "beforeOpeningRoundBrace": true,
 *     "beforeOpeningCurlyBrace": true
 * }
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var x = function a () {};
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = function a() {};
 * var x = function a (){};
 * var x = function a(){};
 * ```
 */
var assert = require('assert');
Function (anonymous_792)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_793)
✓ Was called    configure: function(options) {···
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );

        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }

        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }

        assert(
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace ' +
            'or beforeOpeningRoundBrace property'
        );

        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
    configure: function(options) {
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningRoundBrace' in options) {···
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        if ('beforeOpeningCurlyBrace' in options) {
        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningCurlyBrace' in options) {···
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        assert(
        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
        assert(
Branch LogicalExpression
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace ' +
            'or beforeOpeningRoundBrace property'
        );
        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
Function (anonymous_794)
✓ Was called    getOptionName: function() {···
        return 'requireSpacesInNamedFunctionExpression';
    },
    getOptionName: function() {
        return 'requireSpacesInNamedFunctionExpression';
    },
Function (anonymous_795)
✓ Was called    check: function(file, errors) {···
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;

        file.iterateNodesByType(['FunctionExpression'], function(node) {

            if (node.id) {

                if (beforeOpeningRoundBrace) {
                    var functionToken = file.getFirstNodeToken(node.id);
                    errors.assert.whitespaceBetween({
                        token: functionToken,
                        nextToken: file.getNextToken(functionToken),
                        message: 'Missing space before opening round brace',
                    });
                }

                if (beforeOpeningCurlyBrace) {
                    var bodyToken = file.getFirstNodeToken(node.body);
                    errors.assert.whitespaceBetween({
                        token: file.getPrevToken(bodyToken),
                        nextToken: bodyToken,
                        message: 'Missing space before opening curly brace',
                    });
                }
            }
        });
    }
    check: function(file, errors) {
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;
Function (anonymous_796)
✓ Was called        file.iterateNodesByType(['FunctionExpression'], function(node) {···

            if (node.id) {

                if (beforeOpeningRoundBrace) {
                    var functionToken = file.getFirstNodeToken(node.id);
                    errors.assert.whitespaceBetween({
                        token: functionToken,
                        nextToken: file.getNextToken(functionToken),
                        message: 'Missing space before opening round brace',
                    });
                }

                if (beforeOpeningCurlyBrace) {
                    var bodyToken = file.getFirstNodeToken(node.body);
                    errors.assert.whitespaceBetween({
                        token: file.getPrevToken(bodyToken),
                        nextToken: bodyToken,
                        message: 'Missing space before opening curly brace',
                    });
                }
            }
        });
        file.iterateNodesByType(['FunctionExpression'], function(node) {
Branch IfStatement
✓ Positive was executed (if)            if (node.id) {···

                if (beforeOpeningRoundBrace) {
                    var functionToken = file.getFirstNodeToken(node.id);
                    errors.assert.whitespaceBetween({
                        token: functionToken,
                        nextToken: file.getNextToken(functionToken),
                        message: 'Missing space before opening round brace',
                    });
                }

                if (beforeOpeningCurlyBrace) {
                    var bodyToken = file.getFirstNodeToken(node.body);
                    errors.assert.whitespaceBetween({
                        token: file.getPrevToken(bodyToken),
                        nextToken: bodyToken,
                        message: 'Missing space before opening curly brace',
                    });
                }
            }
✓ Negative was executed (else)            }···
        });
            if (node.id) {
Branch IfStatement
✓ Positive was executed (if)                if (beforeOpeningRoundBrace) {···
                    var functionToken = file.getFirstNodeToken(node.id);
                    errors.assert.whitespaceBetween({
                        token: functionToken,
                        nextToken: file.getNextToken(functionToken),
                        message: 'Missing space before opening round brace',
                    });
                }
✓ Negative was executed (else)                }···

                if (beforeOpeningCurlyBrace) {
                if (beforeOpeningRoundBrace) {
                    var functionToken = file.getFirstNodeToken(node.id);
                    errors.assert.whitespaceBetween({
                        token: functionToken,
                        nextToken: file.getNextToken(functionToken),
                        message: 'Missing space before opening round brace',
                    });
                }
Branch IfStatement
✓ Positive was executed (if)                if (beforeOpeningCurlyBrace) {···
                    var bodyToken = file.getFirstNodeToken(node.body);
                    errors.assert.whitespaceBetween({
                        token: file.getPrevToken(bodyToken),
                        nextToken: bodyToken,
                        message: 'Missing space before opening curly brace',
                    });
                }
✓ Negative was executed (else)                }···
            }
                if (beforeOpeningCurlyBrace) {
                    var bodyToken = file.getFirstNodeToken(node.body);
                    errors.assert.whitespaceBetween({
                        token: file.getPrevToken(bodyToken),
                        nextToken: bodyToken,
                        message: 'Missing space before opening curly brace',
                    });
                }
            }
        });
    }
};

disallow-spaces-in-named-function-expression.js
/**
 * Disallows space before `()` or `{}` in named function expressions.
 *
 * Type: `Object`
 *
 * Values: `"beforeOpeningRoundBrace"` and `"beforeOpeningCurlyBrace"` as child properties.
 * Child properties must be set to `true`.
 *
 * #### Example
 *
 * ```js
 * "disallowSpacesInNamedFunctionExpression": {
 *     "beforeOpeningRoundBrace": true,
 *     "beforeOpeningCurlyBrace": true
 * }
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var x = function a(){};
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = function a() {};
 * var x = function a (){};
 * var x = function a () {};
 * ```
 */
var assert = require('assert');
Function (anonymous_797)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_798)
✓ Was called    configure: function(options) {···
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );

        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }

        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }

        assert(
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace ' +
            'or beforeOpeningRoundBrace property'
        );

        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
    configure: function(options) {
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningRoundBrace' in options) {···
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        if ('beforeOpeningCurlyBrace' in options) {
        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningCurlyBrace' in options) {···
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        assert(
        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
        assert(
Branch LogicalExpression
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace ' +
            'or beforeOpeningRoundBrace property'
        );
        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
Function (anonymous_799)
✓ Was called    getOptionName: function() {···
        return 'disallowSpacesInNamedFunctionExpression';
    },
    getOptionName: function() {
        return 'disallowSpacesInNamedFunctionExpression';
    },
Function (anonymous_800)
✓ Was called    check: function(file, errors) {···
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;

        file.iterateNodesByType(['FunctionExpression'], function(node) {

            // named function expressions only
            if (node.id) {

                if (beforeOpeningRoundBrace) {
                    var functionToken = file.getFirstNodeToken(node.id);
                    errors.assert.noWhitespaceBetween({
                        token: functionToken,
                        nextToken: file.getNextToken(functionToken),
                        message: 'Illegal space before opening round brace',
                    });
                }

                if (beforeOpeningCurlyBrace) {
                    var bodyToken = file.getFirstNodeToken(node.body);
                    errors.assert.noWhitespaceBetween({
                        token: file.getPrevToken(bodyToken),
                        nextToken: bodyToken,
                        message: 'Illegal space before opening curly brace',
                    });
                }
            }
        });
    }
    check: function(file, errors) {
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;
Function (anonymous_801)
✓ Was called        file.iterateNodesByType(['FunctionExpression'], function(node) {···

            // named function expressions only
            if (node.id) {

                if (beforeOpeningRoundBrace) {
                    var functionToken = file.getFirstNodeToken(node.id);
                    errors.assert.noWhitespaceBetween({
                        token: functionToken,
                        nextToken: file.getNextToken(functionToken),
                        message: 'Illegal space before opening round brace',
                    });
                }

                if (beforeOpeningCurlyBrace) {
                    var bodyToken = file.getFirstNodeToken(node.body);
                    errors.assert.noWhitespaceBetween({
                        token: file.getPrevToken(bodyToken),
                        nextToken: bodyToken,
                        message: 'Illegal space before opening curly brace',
                    });
                }
            }
        });
        file.iterateNodesByType(['FunctionExpression'], function(node) {
            // named function expressions only
Branch IfStatement
✓ Positive was executed (if)            if (node.id) {···

                if (beforeOpeningRoundBrace) {
                    var functionToken = file.getFirstNodeToken(node.id);
                    errors.assert.noWhitespaceBetween({
                        token: functionToken,
                        nextToken: file.getNextToken(functionToken),
                        message: 'Illegal space before opening round brace',
                    });
                }

                if (beforeOpeningCurlyBrace) {
                    var bodyToken = file.getFirstNodeToken(node.body);
                    errors.assert.noWhitespaceBetween({
                        token: file.getPrevToken(bodyToken),
                        nextToken: bodyToken,
                        message: 'Illegal space before opening curly brace',
                    });
                }
            }
✓ Negative was executed (else)            }···
        });
            if (node.id) {
Branch IfStatement
✓ Positive was executed (if)                if (beforeOpeningRoundBrace) {···
                    var functionToken = file.getFirstNodeToken(node.id);
                    errors.assert.noWhitespaceBetween({
                        token: functionToken,
                        nextToken: file.getNextToken(functionToken),
                        message: 'Illegal space before opening round brace',
                    });
                }
✓ Negative was executed (else)                }···

                if (beforeOpeningCurlyBrace) {
                if (beforeOpeningRoundBrace) {
                    var functionToken = file.getFirstNodeToken(node.id);
                    errors.assert.noWhitespaceBetween({
                        token: functionToken,
                        nextToken: file.getNextToken(functionToken),
                        message: 'Illegal space before opening round brace',
                    });
                }
Branch IfStatement
✓ Positive was executed (if)                if (beforeOpeningCurlyBrace) {···
                    var bodyToken = file.getFirstNodeToken(node.body);
                    errors.assert.noWhitespaceBetween({
                        token: file.getPrevToken(bodyToken),
                        nextToken: bodyToken,
                        message: 'Illegal space before opening curly brace',
                    });
                }
✓ Negative was executed (else)                }···
            }
                if (beforeOpeningCurlyBrace) {
                    var bodyToken = file.getFirstNodeToken(node.body);
                    errors.assert.noWhitespaceBetween({
                        token: file.getPrevToken(bodyToken),
                        nextToken: bodyToken,
                        message: 'Illegal space before opening curly brace',
                    });
                }
            }
        });
    }
};

require-spaces-in-function-declaration.js
/**
 * Requires space before `()` or `{}` in function declarations.
 *
 * Type: `Object`
 *
 * Values: `"beforeOpeningRoundBrace"` and `"beforeOpeningCurlyBrace"` as child properties.
 * Child properties must be set to `true`.
 *
 * #### Example
 *
 * ```js
 * "requireSpacesInFunctionDeclaration": {
 *     "beforeOpeningRoundBrace": true,
 *     "beforeOpeningCurlyBrace": true
 * }
 * ```
 *
 * ##### Valid
 *
 * ```js
 * function a () {}
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * function a() {}
 * function a (){}
 * function a(){}
 * ```
 */
var assert = require('assert');
Function (anonymous_802)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_803)
✓ Was called    configure: function(options) {···
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );

        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }

        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }

        assert(
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace or beforeOpeningRoundBrace property'
        );

        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
    configure: function(options) {
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningRoundBrace' in options) {···
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        if ('beforeOpeningCurlyBrace' in options) {
        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningCurlyBrace' in options) {···
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        assert(
        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
        assert(
Branch LogicalExpression
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace or beforeOpeningRoundBrace property'
        );
        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
Function (anonymous_804)
✓ Was called    getOptionName: function() {···
        return 'requireSpacesInFunctionDeclaration';
    },
    getOptionName: function() {
        return 'requireSpacesInFunctionDeclaration';
    },
Function (anonymous_805)
✓ Was called    check: function(file, errors) {···
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;

        file.iterateNodesByType(['FunctionDeclaration'], function(node) {

            if (beforeOpeningRoundBrace) {
                // for a named function, use node.id
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.whitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Missing space before opening round brace',
                });
            }

            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Missing space before opening curly brace',
                });
            }
        });
    }
    check: function(file, errors) {
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;
Function (anonymous_806)
✓ Was called        file.iterateNodesByType(['FunctionDeclaration'], function(node) {···

            if (beforeOpeningRoundBrace) {
                // for a named function, use node.id
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.whitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Missing space before opening round brace',
                });
            }

            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Missing space before opening curly brace',
                });
            }
        });
        file.iterateNodesByType(['FunctionDeclaration'], function(node) {
Branch IfStatement
✓ Positive was executed (if)            if (beforeOpeningRoundBrace) {···
                // for a named function, use node.id
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.whitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Missing space before opening round brace',
                });
            }
✓ Negative was executed (else)            }···

            if (beforeOpeningCurlyBrace) {
            if (beforeOpeningRoundBrace) {
                // for a named function, use node.id
Branch LogicalExpression
✗ Was not returned                var functionToken = file.getFirstNodeToken(node.id || node);
✓ Was returned                var functionToken = file.getFirstNodeToken(node.id || node);
                var functionToken = file.getFirstNodeToken(node.id || node);
                errors.assert.whitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Missing space before opening round brace',
                });
            }
Branch IfStatement
✓ Positive was executed (if)            if (beforeOpeningCurlyBrace) {···
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Missing space before opening curly brace',
                });
            }
✓ Negative was executed (else)            }···
        });
            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.whitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Missing space before opening curly brace',
                });
            }
        });
    }
};

disallow-spaces-in-function-declaration.js
/**
 * Disallows space before `()` or `{}` in function declarations.
 *
 * Type: `Object`
 *
 * Values: `"beforeOpeningRoundBrace"` and `"beforeOpeningCurlyBrace"` as child properties.
 * Child properties must be set to `true`.
 *
 * #### Example
 *
 * ```js
 * "disallowSpacesInFunctionDeclaration": {
 *     "beforeOpeningRoundBrace": true,
 *     "beforeOpeningCurlyBrace": true
 * }
 * ```
 *
 * ##### Valid
 *
 * ```js
 * function a(){}
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * function a() {}
 * function a (){}
 * function a () {}
 * ```
 */
var assert = require('assert');
Function (anonymous_807)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_808)
✓ Was called    configure: function(options) {···
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );

        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }

        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }

        assert(
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace or beforeOpeningRoundBrace property'
        );

        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
    configure: function(options) {
        assert(
            typeof options === 'object',
            this.getOptionName() + ' option must be the object'
        );
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningRoundBrace' in options) {···
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        if ('beforeOpeningCurlyBrace' in options) {
        if ('beforeOpeningRoundBrace' in options) {
            assert(
                options.beforeOpeningRoundBrace === true,
                this.getOptionName() + '.beforeOpeningRoundBrace ' +
                'property requires true value or should be removed'
            );
        }
Branch IfStatement
✓ Positive was executed (if)        if ('beforeOpeningCurlyBrace' in options) {···
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
✓ Negative was executed (else)        }···

        assert(
        if ('beforeOpeningCurlyBrace' in options) {
            assert(
                options.beforeOpeningCurlyBrace === true,
                this.getOptionName() + '.beforeOpeningCurlyBrace ' +
                'property requires true value or should be removed'
            );
        }
        assert(
Branch LogicalExpression
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
✓ Was returned            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            options.beforeOpeningCurlyBrace || options.beforeOpeningRoundBrace,
            this.getOptionName() + ' must have beforeOpeningCurlyBrace or beforeOpeningRoundBrace property'
        );
        this._beforeOpeningRoundBrace = Boolean(options.beforeOpeningRoundBrace);
        this._beforeOpeningCurlyBrace = Boolean(options.beforeOpeningCurlyBrace);
    },
Function (anonymous_809)
✓ Was called    getOptionName: function() {···
        return 'disallowSpacesInFunctionDeclaration';
    },
    getOptionName: function() {
        return 'disallowSpacesInFunctionDeclaration';
    },
Function (anonymous_810)
✓ Was called    check: function(file, errors) {···
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;

        file.iterateNodesByType(['FunctionDeclaration'], function(node) {

            if (beforeOpeningRoundBrace) {
                var functionToken = file.getFirstNodeToken(node.id);
                errors.assert.noWhitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Illegal space before opening round brace',
                });
            }

            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Illegal space before opening curly brace',
                });
            }
        });
    }
    check: function(file, errors) {
        var beforeOpeningRoundBrace = this._beforeOpeningRoundBrace;
        var beforeOpeningCurlyBrace = this._beforeOpeningCurlyBrace;
Function (anonymous_811)
✓ Was called        file.iterateNodesByType(['FunctionDeclaration'], function(node) {···

            if (beforeOpeningRoundBrace) {
                var functionToken = file.getFirstNodeToken(node.id);
                errors.assert.noWhitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Illegal space before opening round brace',
                });
            }

            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Illegal space before opening curly brace',
                });
            }
        });
        file.iterateNodesByType(['FunctionDeclaration'], function(node) {
Branch IfStatement
✓ Positive was executed (if)            if (beforeOpeningRoundBrace) {···
                var functionToken = file.getFirstNodeToken(node.id);
                errors.assert.noWhitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Illegal space before opening round brace',
                });
            }
✓ Negative was executed (else)            }···

            if (beforeOpeningCurlyBrace) {
            if (beforeOpeningRoundBrace) {
                var functionToken = file.getFirstNodeToken(node.id);
                errors.assert.noWhitespaceBetween({
                    token: functionToken,
                    nextToken: file.getNextToken(functionToken),
                    message: 'Illegal space before opening round brace',
                });
            }
Branch IfStatement
✓ Positive was executed (if)            if (beforeOpeningCurlyBrace) {···
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Illegal space before opening curly brace',
                });
            }
✓ Negative was executed (else)            }···
        });
            if (beforeOpeningCurlyBrace) {
                var bodyToken = file.getFirstNodeToken(node.body);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(bodyToken),
                    nextToken: bodyToken,
                    message: 'Illegal space before opening curly brace',
                });
            }
        });
    }
};

require-spaces-in-call-expression.js
/**
 * Requires space before `()` in call expressions.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "requireSpacesInCallExpression": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var x = foobar ();
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = foobar();
 * ```
 */
var assert = require('assert');
Function (anonymous_812)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_813)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_814)
✓ Was called    getOptionName: function() {···
        return 'requireSpacesInCallExpression';
    },
    getOptionName: function() {
        return 'requireSpacesInCallExpression';
    },
Function (anonymous_815)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('CallExpression', function(node) {
            var lastCalleeToken = file.getLastNodeToken(node.callee);
            var roundBraceToken = file.findNextToken(lastCalleeToken, 'Punctuator', '(');

            errors.assert.whitespaceBetween({
                token: file.getPrevToken(roundBraceToken),
                nextToken: roundBraceToken,
                message: 'Missing space before opening round brace'
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_816)
✓ Was called        file.iterateNodesByType('CallExpression', function(node) {···
            var lastCalleeToken = file.getLastNodeToken(node.callee);
            var roundBraceToken = file.findNextToken(lastCalleeToken, 'Punctuator', '(');

            errors.assert.whitespaceBetween({
                token: file.getPrevToken(roundBraceToken),
                nextToken: roundBraceToken,
                message: 'Missing space before opening round brace'
            });
        });
        file.iterateNodesByType('CallExpression', function(node) {
            var lastCalleeToken = file.getLastNodeToken(node.callee);
            var roundBraceToken = file.findNextToken(lastCalleeToken, 'Punctuator', '(');
            errors.assert.whitespaceBetween({
                token: file.getPrevToken(roundBraceToken),
                nextToken: roundBraceToken,
                message: 'Missing space before opening round brace'
            });
        });
    }
};

disallow-spaces-in-call-expression.js
/**
 * Disallows space before `()` in call expressions.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowSpacesInCallExpression": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var x = foobar();
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = foobar ();
 * ```
 */
var assert = require('assert');
Function (anonymous_817)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_818)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_819)
✓ Was called    getOptionName: function() {···
        return 'disallowSpacesInCallExpression';
    },
    getOptionName: function() {
        return 'disallowSpacesInCallExpression';
    },
Function (anonymous_820)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('CallExpression', function(node) {
            var lastCalleeToken = file.getLastNodeToken(node.callee);
            var roundBraceToken = file.findNextToken(lastCalleeToken, 'Punctuator', '(');

            errors.assert.noWhitespaceBetween({
                token: file.getPrevToken(roundBraceToken),
                nextToken: roundBraceToken,
                message: 'Illegal space before opening round brace'
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_821)
✓ Was called        file.iterateNodesByType('CallExpression', function(node) {···
            var lastCalleeToken = file.getLastNodeToken(node.callee);
            var roundBraceToken = file.findNextToken(lastCalleeToken, 'Punctuator', '(');

            errors.assert.noWhitespaceBetween({
                token: file.getPrevToken(roundBraceToken),
                nextToken: roundBraceToken,
                message: 'Illegal space before opening round brace'
            });
        });
        file.iterateNodesByType('CallExpression', function(node) {
            var lastCalleeToken = file.getLastNodeToken(node.callee);
            var roundBraceToken = file.findNextToken(lastCalleeToken, 'Punctuator', '(');
            errors.assert.noWhitespaceBetween({
                token: file.getPrevToken(roundBraceToken),
                nextToken: roundBraceToken,
                message: 'Illegal space before opening round brace'
            });
        });
    }
};

validate-parameter-separator.js
/**
 * Enable validation of separators between function parameters. Will ignore newlines.
 *
 * Type: `String`
 *
 * Values:
 *
 *  - `","`: function parameters are immediately followed by a comma
 *  - `", "`: function parameters are immediately followed by a comma and then a space
 *  - `" ,"`: function parameters are immediately followed by a space and then a comma
 *  - `" , "`: function parameters are immediately followed by a space, a comma, and then a space
 *
 * #### Example
 *
 * ```js
 * "validateParameterSeparator": ", "
 * ```
 *
 * ##### Valid
 *
 * ```js
 * function a(b, c) {}
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * function a(b , c) {}
 * ```
 */
var assert = require('assert');
Function (anonymous_822)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_823)
✓ Was called    configure: function(options) {···
        assert(
            typeof options === 'string' && /^[ ]?,[ ]?$/.test(options),
            this.getOptionName() + ' option requires string value containing only a comma and optional spaces'
        );

        this._separator = options;
    },
    configure: function(options) {
        assert(
Branch LogicalExpression
✓ Was returned            typeof options === 'string' && /^[ ]?,[ ]?$/.test(options),
✓ Was returned            typeof options === 'string' && /^[ ]?,[ ]?$/.test(options),
            typeof options === 'string' && /^[ ]?,[ ]?$/.test(options),
            this.getOptionName() + ' option requires string value containing only a comma and optional spaces'
        );
        this._separator = options;
    },
Function (anonymous_824)
✓ Was called    getOptionName: function() {···
        return 'validateParameterSeparator';
    },
    getOptionName: function() {
        return 'validateParameterSeparator';
    },
Function (anonymous_825)
✓ Was called    check: function(file, errors) {···

        var separators = this._separator.split(',');
        var whitespaceBeforeComma = Boolean(separators.shift());
        var whitespaceAfterComma = Boolean(separators.pop());

        file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {

            node.params.forEach(function(paramNode) {

                var prevParamToken = file.getFirstNodeToken(paramNode);
                var punctuatorToken = file.getNextToken(prevParamToken);

                if (punctuatorToken.value === ',') {

                    if (whitespaceBeforeComma) {
                        errors.assert.spacesBetween({
                            token: prevParamToken,
                            nextToken: punctuatorToken,
                            exactly: 1,
                            message: 'One space required after function parameter \'' + prevParamToken.value + '\''
                        });
                    } else {
                        errors.assert.noWhitespaceBetween({
                            token: prevParamToken,
                            nextToken: punctuatorToken,
                            message: 'Unexpected space after function parameter \'' + prevParamToken.value + '\''
                        });
                    }

                    var nextParamToken = file.getNextToken(punctuatorToken);

                    if (whitespaceAfterComma) {
                        errors.assert.spacesBetween({
                            token: punctuatorToken,
                            nextToken: nextParamToken,
                            exactly: 1,
                            message: 'One space required before function parameter \'' + nextParamToken.value + '\''
                        });
                    } else {
                        errors.assert.noWhitespaceBetween({
                            token: punctuatorToken,
                            nextToken: nextParamToken,
                            message: 'Unexpected space before function parameter \'' + nextParamToken.value + '\''
                        });
                    }
                }
            });
        });
    }
    check: function(file, errors) {
        var separators = this._separator.split(',');
        var whitespaceBeforeComma = Boolean(separators.shift());
        var whitespaceAfterComma = Boolean(separators.pop());
Function (anonymous_826)
✓ Was called        file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {···

            node.params.forEach(function(paramNode) {

                var prevParamToken = file.getFirstNodeToken(paramNode);
                var punctuatorToken = file.getNextToken(prevParamToken);

                if (punctuatorToken.value === ',') {

                    if (whitespaceBeforeComma) {
                        errors.assert.spacesBetween({
                            token: prevParamToken,
                            nextToken: punctuatorToken,
                            exactly: 1,
                            message: 'One space required after function parameter \'' + prevParamToken.value + '\''
                        });
                    } else {
                        errors.assert.noWhitespaceBetween({
                            token: prevParamToken,
                            nextToken: punctuatorToken,
                            message: 'Unexpected space after function parameter \'' + prevParamToken.value + '\''
                        });
                    }

                    var nextParamToken = file.getNextToken(punctuatorToken);

                    if (whitespaceAfterComma) {
                        errors.assert.spacesBetween({
                            token: punctuatorToken,
                            nextToken: nextParamToken,
                            exactly: 1,
                            message: 'One space required before function parameter \'' + nextParamToken.value + '\''
                        });
                    } else {
                        errors.assert.noWhitespaceBetween({
                            token: punctuatorToken,
                            nextToken: nextParamToken,
                            message: 'Unexpected space before function parameter \'' + nextParamToken.value + '\''
                        });
                    }
                }
            });
        });
        file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {
Function (anonymous_827)
✓ Was called            node.params.forEach(function(paramNode) {···

                var prevParamToken = file.getFirstNodeToken(paramNode);
                var punctuatorToken = file.getNextToken(prevParamToken);

                if (punctuatorToken.value === ',') {

                    if (whitespaceBeforeComma) {
                        errors.assert.spacesBetween({
                            token: prevParamToken,
                            nextToken: punctuatorToken,
                            exactly: 1,
                            message: 'One space required after function parameter \'' + prevParamToken.value + '\''
                        });
                    } else {
                        errors.assert.noWhitespaceBetween({
                            token: prevParamToken,
                            nextToken: punctuatorToken,
                            message: 'Unexpected space after function parameter \'' + prevParamToken.value + '\''
                        });
                    }

                    var nextParamToken = file.getNextToken(punctuatorToken);

                    if (whitespaceAfterComma) {
                        errors.assert.spacesBetween({
                            token: punctuatorToken,
                            nextToken: nextParamToken,
                            exactly: 1,
                            message: 'One space required before function parameter \'' + nextParamToken.value + '\''
                        });
                    } else {
                        errors.assert.noWhitespaceBetween({
                            token: punctuatorToken,
                            nextToken: nextParamToken,
                            message: 'Unexpected space before function parameter \'' + nextParamToken.value + '\''
                        });
                    }
                }
            });
            node.params.forEach(function(paramNode) {
                var prevParamToken = file.getFirstNodeToken(paramNode);
                var punctuatorToken = file.getNextToken(prevParamToken);
Branch IfStatement
✓ Positive was executed (if)                if (punctuatorToken.value === ',') {···

                    if (whitespaceBeforeComma) {
                        errors.assert.spacesBetween({
                            token: prevParamToken,
                            nextToken: punctuatorToken,
                            exactly: 1,
                            message: 'One space required after function parameter \'' + prevParamToken.value + '\''
                        });
                    } else {
                        errors.assert.noWhitespaceBetween({
                            token: prevParamToken,
                            nextToken: punctuatorToken,
                            message: 'Unexpected space after function parameter \'' + prevParamToken.value + '\''
                        });
                    }

                    var nextParamToken = file.getNextToken(punctuatorToken);

                    if (whitespaceAfterComma) {
                        errors.assert.spacesBetween({
                            token: punctuatorToken,
                            nextToken: nextParamToken,
                            exactly: 1,
                            message: 'One space required before function parameter \'' + nextParamToken.value + '\''
                        });
                    } else {
                        errors.assert.noWhitespaceBetween({
                            token: punctuatorToken,
                            nextToken: nextParamToken,
                            message: 'Unexpected space before function parameter \'' + nextParamToken.value + '\''
                        });
                    }
                }
✓ Negative was executed (else)                }···
            });
                if (punctuatorToken.value === ',') {
Branch IfStatement
✓ Positive was executed (if)                    if (whitespaceBeforeComma) {···
                        errors.assert.spacesBetween({
                            token: prevParamToken,
                            nextToken: punctuatorToken,
                            exactly: 1,
                            message: 'One space required after function parameter \'' + prevParamToken.value + '\''
                        });
                    } else {
✓ Negative was executed (else)                    } else {···
                        errors.assert.noWhitespaceBetween({
                            token: prevParamToken,
                            nextToken: punctuatorToken,
                            message: 'Unexpected space after function parameter \'' + prevParamToken.value + '\''
                        });
                    }
                    if (whitespaceBeforeComma) {
                        errors.assert.spacesBetween({
                            token: prevParamToken,
                            nextToken: punctuatorToken,
                            exactly: 1,
                            message: 'One space required after function parameter \'' + prevParamToken.value + '\''
                        });
                    } else {
                        errors.assert.noWhitespaceBetween({
                            token: prevParamToken,
                            nextToken: punctuatorToken,
                            message: 'Unexpected space after function parameter \'' + prevParamToken.value + '\''
                        });
                    }
                    var nextParamToken = file.getNextToken(punctuatorToken);
Branch IfStatement
✓ Positive was executed (if)                    if (whitespaceAfterComma) {···
                        errors.assert.spacesBetween({
                            token: punctuatorToken,
                            nextToken: nextParamToken,
                            exactly: 1,
                            message: 'One space required before function parameter \'' + nextParamToken.value + '\''
                        });
                    } else {
✓ Negative was executed (else)                    } else {···
                        errors.assert.noWhitespaceBetween({
                            token: punctuatorToken,
                            nextToken: nextParamToken,
                            message: 'Unexpected space before function parameter \'' + nextParamToken.value + '\''
                        });
                    }
                    if (whitespaceAfterComma) {
                        errors.assert.spacesBetween({
                            token: punctuatorToken,
                            nextToken: nextParamToken,
                            exactly: 1,
                            message: 'One space required before function parameter \'' + nextParamToken.value + '\''
                        });
                    } else {
                        errors.assert.noWhitespaceBetween({
                            token: punctuatorToken,
                            nextToken: nextParamToken,
                            message: 'Unexpected space before function parameter \'' + nextParamToken.value + '\''
                        });
                    }
                }
            });
        });
    }
};

require-space-between-arguments.js
/**
 * Ensure there are spaces after argument separators in call expressions.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "requireSpaceBetweenArguments": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * a(b, c);
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * a(b,c);
 * ```
 */
var assert = require('assert');
Function (anonymous_828)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_829)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_830)
✓ Was called    getOptionName: function() {···
        return 'requireSpaceBetweenArguments';
    },
    getOptionName: function() {
        return 'requireSpaceBetweenArguments';
    },
Function (anonymous_831)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType(['CallExpression'], function(node) {
            node.arguments.forEach(function(param) {
                var punctuatorToken = file.getPrevToken(file.getFirstNodeToken(param));
                if (punctuatorToken.value === ',') {
                    errors.assert.whitespaceBetween({
                        token: punctuatorToken,
                        nextToken: file.getNextToken(punctuatorToken)
                    });
                }
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_832)
✓ Was called        file.iterateNodesByType(['CallExpression'], function(node) {···
            node.arguments.forEach(function(param) {
                var punctuatorToken = file.getPrevToken(file.getFirstNodeToken(param));
                if (punctuatorToken.value === ',') {
                    errors.assert.whitespaceBetween({
                        token: punctuatorToken,
                        nextToken: file.getNextToken(punctuatorToken)
                    });
                }
            });
        });
        file.iterateNodesByType(['CallExpression'], function(node) {
Function (anonymous_833)
✓ Was called            node.arguments.forEach(function(param) {···
                var punctuatorToken = file.getPrevToken(file.getFirstNodeToken(param));
                if (punctuatorToken.value === ',') {
                    errors.assert.whitespaceBetween({
                        token: punctuatorToken,
                        nextToken: file.getNextToken(punctuatorToken)
                    });
                }
            });
            node.arguments.forEach(function(param) {
                var punctuatorToken = file.getPrevToken(file.getFirstNodeToken(param));
Branch IfStatement
✓ Positive was executed (if)                if (punctuatorToken.value === ',') {···
                    errors.assert.whitespaceBetween({
                        token: punctuatorToken,
                        nextToken: file.getNextToken(punctuatorToken)
                    });
                }
✓ Negative was executed (else)                }···
            });
                if (punctuatorToken.value === ',') {
                    errors.assert.whitespaceBetween({
                        token: punctuatorToken,
                        nextToken: file.getNextToken(punctuatorToken)
                    });
                }
            });
        });
    }
};

disallow-space-between-arguments.js
/**
 * Ensure there are no spaces after argument separators in call expressions.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowSpaceBetweenArguments": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * a(b,c);
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * a(b, c);
 * ```
 */
var assert = require('assert');
Function (anonymous_834)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_835)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_836)
✓ Was called    getOptionName: function() {···
        return 'disallowSpaceBetweenArguments';
    },
    getOptionName: function() {
        return 'disallowSpaceBetweenArguments';
    },
Function (anonymous_837)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType(['CallExpression'], function(node) {
            node.arguments.forEach(function(param) {
                var token = file.getFirstNodeToken(param);
                var punctuatorToken = file.getPrevToken(token);

                if (punctuatorToken.value === ',') {
                    errors.assert.noWhitespaceBetween({
                        token: punctuatorToken,
                        nextToken: file.getNextToken(punctuatorToken),
                        message: 'Illegal space between arguments'
                    });
                }
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_838)
✓ Was called        file.iterateNodesByType(['CallExpression'], function(node) {···
            node.arguments.forEach(function(param) {
                var token = file.getFirstNodeToken(param);
                var punctuatorToken = file.getPrevToken(token);

                if (punctuatorToken.value === ',') {
                    errors.assert.noWhitespaceBetween({
                        token: punctuatorToken,
                        nextToken: file.getNextToken(punctuatorToken),
                        message: 'Illegal space between arguments'
                    });
                }
            });
        });
        file.iterateNodesByType(['CallExpression'], function(node) {
Function (anonymous_839)
✓ Was called            node.arguments.forEach(function(param) {···
                var token = file.getFirstNodeToken(param);
                var punctuatorToken = file.getPrevToken(token);

                if (punctuatorToken.value === ',') {
                    errors.assert.noWhitespaceBetween({
                        token: punctuatorToken,
                        nextToken: file.getNextToken(punctuatorToken),
                        message: 'Illegal space between arguments'
                    });
                }
            });
            node.arguments.forEach(function(param) {
                var token = file.getFirstNodeToken(param);
                var punctuatorToken = file.getPrevToken(token);
Branch IfStatement
✓ Positive was executed (if)                if (punctuatorToken.value === ',') {···
                    errors.assert.noWhitespaceBetween({
                        token: punctuatorToken,
                        nextToken: file.getNextToken(punctuatorToken),
                        message: 'Illegal space between arguments'
                    });
                }
✓ Negative was executed (else)                }···
            });
                if (punctuatorToken.value === ',') {
                    errors.assert.noWhitespaceBetween({
                        token: punctuatorToken,
                        nextToken: file.getNextToken(punctuatorToken),
                        message: 'Illegal space between arguments'
                    });
                }
            });
        });
    }
};

require-capitalized-constructors.js
/**
 * Requires constructors to be capitalized (except for `this`)
 *
 * Types: `Boolean` or `Object`
 *
 * Values: `true` or Object with `allExcept` Array of quoted identifiers which are exempted
 *
 * JSHint: [`newcap`](http://jshint.com/docs/options/#newcap)
 *
 * #### Example
 *
 * ```js
 * "requireCapitalizedConstructors": true
 * "requireCapitalizedConstructors": {
 *     allExcept: ["somethingNative"]
 * }
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var a = new B();
 * var c = new this();
 * var d = new somethingNative();
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var d = new e();
 * ```
 */
var assert = require('assert');
Function (anonymous_840)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_841)
✓ Was called    configure: function(options) {···
        assert(
            options === true || Array.isArray(options.allExcept),
            this.getOptionName() + ' option requires a true value or an object of exceptions'
        );
        this._allowedConstructors = {};

        var allExcept = options.allExcept;
        if (allExcept) {
            for (var i = 0, l = allExcept.length; i < l; i++) {
                this._allowedConstructors[allExcept[i]] = true;
            }
        }
    },
    configure: function(options) {
        assert(
Branch LogicalExpression
✓ Was returned            options === true || Array.isArray(options.allExcept),
✓ Was returned            options === true || Array.isArray(options.allExcept),
            options === true || Array.isArray(options.allExcept),
            this.getOptionName() + ' option requires a true value or an object of exceptions'
        );
        this._allowedConstructors = {};
        var allExcept = options.allExcept;
Branch IfStatement
✓ Positive was executed (if)        if (allExcept) {···
            for (var i = 0, l = allExcept.length; i < l; i++) {
                this._allowedConstructors[allExcept[i]] = true;
            }
        }
✓ Negative was executed (else)        }···
    },
        if (allExcept) {
            for (var i = 0, l = allExcept.length; i < l; i++) {
                this._allowedConstructors[allExcept[i]] = true;
            }
        }
    },
Function (anonymous_842)
✓ Was called    getOptionName: function() {···
        return 'requireCapitalizedConstructors';
    },
    getOptionName: function() {
        return 'requireCapitalizedConstructors';
    },
Function (anonymous_843)
✓ Was called    check: function(file, errors) {···
        var allowedConstructors = this._allowedConstructors;

        file.iterateNodesByType('NewExpression', function(node) {
            if (node.callee.type === 'Identifier' &&
                !allowedConstructors[node.callee.name] &&
                node.callee.name[0].toUpperCase() !== node.callee.name[0]
            ) {
                errors.add(
                    'Constructor functions should be capitalized',
                    node.callee.loc.start.line,
                    node.callee.loc.start.column
                );
            }
        });
    }
    check: function(file, errors) {
        var allowedConstructors = this._allowedConstructors;
Function (anonymous_844)
✓ Was called        file.iterateNodesByType('NewExpression', function(node) {···
            if (node.callee.type === 'Identifier' &&
                !allowedConstructors[node.callee.name] &&
                node.callee.name[0].toUpperCase() !== node.callee.name[0]
            ) {
                errors.add(
                    'Constructor functions should be capitalized',
                    node.callee.loc.start.line,
                    node.callee.loc.start.column
                );
            }
        });
        file.iterateNodesByType('NewExpression', function(node) {
Branch IfStatement
✓ Positive was executed (if)            ) {···
                errors.add(
                    'Constructor functions should be capitalized',
                    node.callee.loc.start.line,
                    node.callee.loc.start.column
                );
            }
✓ Negative was executed (else)            }···
        });
Branch LogicalExpression
✓ Was returned                node.callee.name[0].toUpperCase() !== node.callee.name[0]
✓ Was returned            if (node.callee.type === 'Identifier' &&···
                !allowedConstructors[node.callee.name] &&
Branch LogicalExpression
✓ Was returned                !allowedConstructors[node.callee.name] &&
✓ Was returned            if (node.callee.type === 'Identifier' &&
            if (node.callee.type === 'Identifier' &&
                !allowedConstructors[node.callee.name] &&
                node.callee.name[0].toUpperCase() !== node.callee.name[0]
            ) {
                errors.add(
                    'Constructor functions should be capitalized',
                    node.callee.loc.start.line,
                    node.callee.loc.start.column
                );
            }
        });
    }
};

safe-context-keyword.js
/**
 * Option to check `var that = this` expressions
 *
 * Types: `Array` or `String`
 *
 * Values: String value used for context local declaration
 *
 * #### Example
 *
 * ```js
 * "safeContextKeyword": ["that"]
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var that = this;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var _this = this;
 * ```
 */
var assert = require('assert');
Function (anonymous_845)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_846)
✓ Was called    configure: function(keywords) {···
        assert(
            Array.isArray(keywords) || typeof keywords === 'string',
            this.getOptionName() + ' option requires string or array value'
        );

        this._keywords = keywords;
    },
    configure: function(keywords) {
        assert(
Branch LogicalExpression
✓ Was returned            Array.isArray(keywords) || typeof keywords === 'string',
✓ Was returned            Array.isArray(keywords) || typeof keywords === 'string',
            Array.isArray(keywords) || typeof keywords === 'string',
            this.getOptionName() + ' option requires string or array value'
        );
        this._keywords = keywords;
    },
Function (anonymous_847)
✓ Was called    getOptionName: function() {···
        return 'safeContextKeyword';
    },
    getOptionName: function() {
        return 'safeContextKeyword';
    },
Function (anonymous_848)
✓ Was called    check: function(file, errors) {···
        var keywords = typeof this._keywords === 'string' ? [this._keywords] : this._keywords;

        // var that = this
        file.iterateNodesByType('VariableDeclaration', function(node) {
            for (var i = 0; i < node.declarations.length; i++) {
                var decl = node.declarations[i];

                // decl.init === null in case of "var foo;"
                if (decl.init &&
                    (decl.init.type === 'ThisExpression' && checkKeywords(decl.id.name, keywords))
                ) {
                    errors.add(
                        'You should use "' + keywords.join('" or "') + '" to save a reference to "this"',
                        node.loc.start
                    );
                }
            }
        });

        // that = this
        file.iterateNodesByType('AssignmentExpression', function(node) {

            if (
                // filter property assignments "foo.bar = this"
                node.left.type === 'Identifier' &&
                (node.right.type === 'ThisExpression' && checkKeywords(node.left.name, keywords))
            ) {
                errors.add(
                    'You should use "' + keywords.join('" or "') + '" to save a reference to "this"',
                    node.loc.start
                );
            }
        });
    }
    check: function(file, errors) {
Branch ConditionalExpression
✓ Positive was returned (? ...)        var keywords = typeof this._keywords === 'string' ? [this._keywords] : this._keywords;
✓ Negative was returned (: ...)        var keywords = typeof this._keywords === 'string' ? [this._keywords] : this._keywords;
        var keywords = typeof this._keywords === 'string' ? [this._keywords] : this._keywords;
        // var that = this
Function (anonymous_849)
✓ Was called        file.iterateNodesByType('VariableDeclaration', function(node) {···
            for (var i = 0; i < node.declarations.length; i++) {
                var decl = node.declarations[i];

                // decl.init === null in case of "var foo;"
                if (decl.init &&
                    (decl.init.type === 'ThisExpression' && checkKeywords(decl.id.name, keywords))
                ) {
                    errors.add(
                        'You should use "' + keywords.join('" or "') + '" to save a reference to "this"',
                        node.loc.start
                    );
                }
            }
        });
        file.iterateNodesByType('VariableDeclaration', function(node) {
            for (var i = 0; i < node.declarations.length; i++) {
                var decl = node.declarations[i];
                // decl.init === null in case of "var foo;"
Branch IfStatement
✓ Positive was executed (if)                ) {···
                    errors.add(
                        'You should use "' + keywords.join('" or "') + '" to save a reference to "this"',
                        node.loc.start
                    );
                }
✓ Negative was executed (else)                }···
            }
Branch LogicalExpression
✓ Was returned                    (decl.init.type === 'ThisExpression' && checkKeywords(decl.id.name, keywords))
✓ Was returned                if (decl.init &&
                if (decl.init &&
Branch LogicalExpression
✓ Was returned                    (decl.init.type === 'ThisExpression' && checkKeywords(decl.id.name, keywords))
✓ Was returned                    (decl.init.type === 'ThisExpression' && checkKeywords(decl.id.name, keywords))
                    (decl.init.type === 'ThisExpression' && checkKeywords(decl.id.name, keywords))
                ) {
                    errors.add(
                        'You should use "' + keywords.join('" or "') + '" to save a reference to "this"',
                        node.loc.start
                    );
                }
            }
        });
        // that = this
Function (anonymous_850)
✓ Was called        file.iterateNodesByType('AssignmentExpression', function(node) {···

            if (
                // filter property assignments "foo.bar = this"
                node.left.type === 'Identifier' &&
                (node.right.type === 'ThisExpression' && checkKeywords(node.left.name, keywords))
            ) {
                errors.add(
                    'You should use "' + keywords.join('" or "') + '" to save a reference to "this"',
                    node.loc.start
                );
            }
        });
        file.iterateNodesByType('AssignmentExpression', function(node) {
Branch IfStatement
✓ Positive was executed (if)            ) {···
                errors.add(
                    'You should use "' + keywords.join('" or "') + '" to save a reference to "this"',
                    node.loc.start
                );
            }
✓ Negative was executed (else)            }···
        });
            if (
                // filter property assignments "foo.bar = this"
Branch LogicalExpression
✓ Was returned                (node.right.type === 'ThisExpression' && checkKeywords(node.left.name, keywords))
✓ Was returned                node.left.type === 'Identifier' &&
                node.left.type === 'Identifier' &&
Branch LogicalExpression
✓ Was returned                (node.right.type === 'ThisExpression' && checkKeywords(node.left.name, keywords))
✓ Was returned                (node.right.type === 'ThisExpression' && checkKeywords(node.left.name, keywords))
                (node.right.type === 'ThisExpression' && checkKeywords(node.left.name, keywords))
            ) {
                errors.add(
                    'You should use "' + keywords.join('" or "') + '" to save a reference to "this"',
                    node.loc.start
                );
            }
        });
    }
};
/**
 * Check if at least one keyword equals to passed name
 * @param {String} name
 * @param {Array} keywords
 * @return {Boolean}
 */
Function checkKeywords
✓ Was calledfunction checkKeywords(name, keywords) {···
    for (var i = 0; i < keywords.length; i++) {
        if (name === keywords[i]) {
            return false;
        }
    }

    return true;
}
function checkKeywords(name, keywords) {
    for (var i = 0; i < keywords.length; i++) {
Branch IfStatement
✓ Positive was executed (if)        if (name === keywords[i]) {···
            return false;
        }
✓ Negative was executed (else)        }···
    }
        if (name === keywords[i]) {
            return false;
        }
    }
    return true;
}

require-dot-notation.js
/**
 * Requires member expressions to use dot notation when possible
 *
 * Types: `Boolean` or `String`
 *
 * Values:
 *  - `true`
 *  - `"except_snake_case"` allow quoted snake cased identifiers
 *
 * JSHint: [`sub`](http://www.jshint.com/docs/options/#sub)
 *
 * #### Example
 *
 * ```js
 * "requireDotNotation": true
 * ```
 *
 * ##### Valid for `true`
 *
 * ```js
 * var a = b[c];
 * var a = b.c;
 * var a = b[c.d];
 * var a = b[1];
 * var a = b['while']; //reserved word
 * ```
 *
 * ##### Valid for `"except_snake_case"`
 * ```
 * var a = b[c];
 * var a = b.c;
 * var a = b['snake_cased'];
 * var a = b['camelCased_butWithSnakes'];
 * ```
 *
 * ##### Invalid for `true`
 *
 * ```js
 * var a = b['c'];
 * var a = b['snake_cased'];
 * var a = b['_camelCased'];
 * var a = b['camelCased_'];
 * ```
 *
 * ##### Invalid for `"except_snake_case"`
 *
 * ```js
 * var a = b['c'];
 * ```
 *
 * #### Example for `"es3": false` or `"es3": null`
 *
 * ```js
 * "requireDotNotation": true,
 * "es3": false
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var a = b[c];
 * var a = b.c;
 * var a = b[c.d];
 * var a = b[1];
 * var a = b.while;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var a = b['c'];
 * var a = b['while']; // reserved words can be property names in ES5
 * ```
 */
var assert = require('assert');
var utils = require('../utils');
Function (anonymous_852)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_853)
✓ Was called    configure: function(options) {···
        assert(
            options === true || options === 'except_snake_case',
            this.getOptionName() + ' option requires a true value or "except_snake_case"'
        );
        this._exceptSnakeCase = options === 'except_snake_case';
    },
    configure: function(options) {
        assert(
Branch LogicalExpression
✓ Was returned            options === true || options === 'except_snake_case',
✓ Was returned            options === true || options === 'except_snake_case',
            options === true || options === 'except_snake_case',
            this.getOptionName() + ' option requires a true value or "except_snake_case"'
        );
        this._exceptSnakeCase = options === 'except_snake_case';
    },
Function (anonymous_854)
✓ Was called    getOptionName: function() {···
        return 'requireDotNotation';
    },
    getOptionName: function() {
        return 'requireDotNotation';
    },
Function (anonymous_855)
✓ Was called    check: function(file, errors) {···
        var exceptSnakeCase = this._exceptSnakeCase;

        function isES3Allowed(value) {
            return file.getDialect() === 'es3' && (utils.isEs3Keyword(value) || utils.isEs3FutureReservedWord(value));
        }

        file.iterateNodesByType('MemberExpression', function(node) {
            if (!node.computed || node.property.type !== 'Literal') {
                return;
            }

            var value = node.property.value;
            if (typeof value === 'number' || (typeof value === 'string' && (
                !utils.isValidIdentifierName(value) ||
                exceptSnakeCase && utils.isSnakeCased(utils.trimUnderscores(value))
            ))) {
                return;
            }

            if (value === null ||
                typeof value === 'boolean' ||
                value === 'null' ||
                value === 'true' ||
                value === 'false' ||
                isES3Allowed(value)
            ) {
                return;
            }

            errors.add(
                'Use dot notation instead of brackets for member expressions',
                node.property.loc.start
            );
        });
    }
    check: function(file, errors) {
        var exceptSnakeCase = this._exceptSnakeCase;
Function isES3Allowed
✓ Was called        function isES3Allowed(value) {···
            return file.getDialect() === 'es3' && (utils.isEs3Keyword(value) || utils.isEs3FutureReservedWord(value));
        }
        function isES3Allowed(value) {
Branch LogicalExpression
✓ Was returned            return file.getDialect() === 'es3' && (utils.isEs3Keyword(value) || utils.isEs3FutureReservedWord(value));
✓ Was returned            return file.getDialect() === 'es3' && (utils.isEs3Keyword(value) || utils.isEs3FutureReservedWord(value));
Branch LogicalExpression
✓ Was returned            return file.getDialect() === 'es3' && (utils.isEs3Keyword(value) || utils.isEs3FutureReservedWord(value));
✓ Was returned            return file.getDialect() === 'es3' && (utils.isEs3Keyword(value) || utils.isEs3FutureReservedWord(value));
            return file.getDialect() === 'es3' && (utils.isEs3Keyword(value) || utils.isEs3FutureReservedWord(value));
        }
Function (anonymous_857)
✓ Was called        file.iterateNodesByType('MemberExpression', function(node) {···
            if (!node.computed || node.property.type !== 'Literal') {
                return;
            }

            var value = node.property.value;
            if (typeof value === 'number' || (typeof value === 'string' && (
                !utils.isValidIdentifierName(value) ||
                exceptSnakeCase && utils.isSnakeCased(utils.trimUnderscores(value))
            ))) {
                return;
            }

            if (value === null ||
                typeof value === 'boolean' ||
                value === 'null' ||
                value === 'true' ||
                value === 'false' ||
                isES3Allowed(value)
            ) {
                return;
            }

            errors.add(
                'Use dot notation instead of brackets for member expressions',
                node.property.loc.start
            );
        });
        file.iterateNodesByType('MemberExpression', function(node) {
Branch IfStatement
✓ Positive was executed (if)            if (!node.computed || node.property.type !== 'Literal') {···
                return;
            }
✓ Negative was executed (else)            }···

            var value = node.property.value;
Branch LogicalExpression
✓ Was returned            if (!node.computed || node.property.type !== 'Literal') {
✓ Was returned            if (!node.computed || node.property.type !== 'Literal') {
            if (!node.computed || node.property.type !== 'Literal') {
                return;
            }
            var value = node.property.value;
Branch IfStatement
✓ Positive was executed (if)            ))) {···
                return;
            }
✓ Negative was executed (else)            }···

            if (value === null ||
Branch LogicalExpression
✓ Was returned            if (typeof value === 'number' || (typeof value === 'string' && (···
                !utils.isValidIdentifierName(value) ||
                exceptSnakeCase && utils.isSnakeCased(utils.trimUnderscores(value))
            ))) {
✓ Was returned            if (typeof value === 'number' || (typeof value === 'string' && (
Branch LogicalExpression
✓ Was returned                !utils.isValidIdentifierName(value) ||···
                exceptSnakeCase && utils.isSnakeCased(utils.trimUnderscores(value))
✓ Was returned            if (typeof value === 'number' || (typeof value === 'string' && (
            if (typeof value === 'number' || (typeof value === 'string' && (
Branch LogicalExpression
✓ Was returned                exceptSnakeCase && utils.isSnakeCased(utils.trimUnderscores(value))
✓ Was returned                !utils.isValidIdentifierName(value) ||
                !utils.isValidIdentifierName(value) ||
Branch LogicalExpression
✓ Was returned                exceptSnakeCase && utils.isSnakeCased(utils.trimUnderscores(value))
✓ Was returned                exceptSnakeCase && utils.isSnakeCased(utils.trimUnderscores(value))
                exceptSnakeCase && utils.isSnakeCased(utils.trimUnderscores(value))
            ))) {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            ) {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.add(
Branch LogicalExpression
✓ Was returned                isES3Allowed(value)
✓ Was returned            if (value === null ||···
                typeof value === 'boolean' ||
                value === 'null' ||
                value === 'true' ||
                value === 'false' ||
Branch LogicalExpression
✓ Was returned                value === 'false' ||
✓ Was returned            if (value === null ||···
                typeof value === 'boolean' ||
                value === 'null' ||
                value === 'true' ||
Branch LogicalExpression
✓ Was returned                value === 'true' ||
✓ Was returned            if (value === null ||···
                typeof value === 'boolean' ||
                value === 'null' ||
Branch LogicalExpression
✓ Was returned                value === 'null' ||
✓ Was returned            if (value === null ||···
                typeof value === 'boolean' ||
Branch LogicalExpression
✓ Was returned                typeof value === 'boolean' ||
✓ Was returned            if (value === null ||
            if (value === null ||
                typeof value === 'boolean' ||
                value === 'null' ||
                value === 'true' ||
                value === 'false' ||
                isES3Allowed(value)
            ) {
                return;
            }
            errors.add(
                'Use dot notation instead of brackets for member expressions',
                node.property.loc.start
            );
        });
    }
};

require-space-after-line-comment.js
/**
 * Requires that a line comment (`//`) be followed by a space.
 *
 * Types: `Boolean`, `Object` or `String`
 *
 * Values:
 *  - `true`
 *  - `"allowSlash"` (*deprecated* use `"allExcept": ["/"]`) allows `/// ` format
 *  - `Object`:
 *     - `allExcept`: array of allowed strings before space `//(here) `
 *
 * #### Example
 *
 * ```js
 * "requireSpaceAfterLineComment": { "allExcept": ["#", "="] }
 * ```
 *
 * ##### Valid
 *
 * ```js
 * // A comment
 * /*A comment*\/
 * //# sourceURL=filename.js
 * //= require something
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * //A comment
 * ```
 */
var assert = require('assert');
Function (anonymous_858)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_859)
✓ Was called    configure: function(options) {···
        assert(
            options === true ||
            options === 'allowSlash' ||
            typeof options === 'object',
            this.getOptionName() + ' option requires a true value ' +
            'or an object with String[] `allExcept` property'
        );

        // verify first item in `allExcept` property in object (if it's an object)
        assert(
            typeof options !== 'object' ||
            Array.isArray(options.allExcept) &&
            typeof options.allExcept[0] === 'string',
            'Property `allExcept` in ' + this.getOptionName() + ' should be an array of strings'
        );

        // don't check triple slashed comments, microsoft js doc convention. see #593
        // exceptions. see #592
        // need to drop allowSlash support in 2.0. Fixes #697
        this._allExcept = options === 'allowSlash' ? ['/'] :
            options.allExcept || [];
    },
    configure: function(options) {
        assert(
Branch LogicalExpression
✓ Was returned            typeof options === 'object',
✓ Was returned            options === true ||···
            options === 'allowSlash' ||
Branch LogicalExpression
✓ Was returned            options === 'allowSlash' ||
✓ Was returned            options === true ||
            options === true ||
            options === 'allowSlash' ||
            typeof options === 'object',
            this.getOptionName() + ' option requires a true value ' +
            'or an object with String[] `allExcept` property'
        );
        // verify first item in `allExcept` property in object (if it's an object)
        assert(
Branch LogicalExpression
✓ Was returned            Array.isArray(options.allExcept) &&···
            typeof options.allExcept[0] === 'string',
✓ Was returned            typeof options !== 'object' ||
            typeof options !== 'object' ||
Branch LogicalExpression
✓ Was returned            typeof options.allExcept[0] === 'string',
✗ Was not returned            Array.isArray(options.allExcept) &&
            Array.isArray(options.allExcept) &&
            typeof options.allExcept[0] === 'string',
            'Property `allExcept` in ' + this.getOptionName() + ' should be an array of strings'
        );
        // don't check triple slashed comments, microsoft js doc convention. see #593
        // exceptions. see #592
        // need to drop allowSlash support in 2.0. Fixes #697
Branch ConditionalExpression
✓ Positive was returned (? ...)        this._allExcept = options === 'allowSlash' ? ['/'] :
✓ Negative was returned (: ...)            options.allExcept || [];
        this._allExcept = options === 'allowSlash' ? ['/'] :
Branch LogicalExpression
✓ Was returned            options.allExcept || [];
✓ Was returned            options.allExcept || [];
            options.allExcept || [];
    },
Function (anonymous_860)
✓ Was called    getOptionName: function() {···
        return 'requireSpaceAfterLineComment';
    },
    getOptionName: function() {
        return 'requireSpaceAfterLineComment';
    },
Function (anonymous_861)
✓ Was called    check: function(file, errors) {···
        var allExcept = this._allExcept;

        file.iterateTokensByType('Line', function(comment) {
            var value = comment.value;

            // cutout exceptions
            allExcept.forEach(function(el) {
                if (value.indexOf(el) === 0) {
                    value = value.substr(el.length);
                }
            });

            if (value.length === 0) {
                return;
            }

            if (value[0] !== ' ') {
                errors.add('Missing space after line comment', comment.loc.start);
            }
        });
    }
    check: function(file, errors) {
        var allExcept = this._allExcept;
Function (anonymous_862)
✓ Was called        file.iterateTokensByType('Line', function(comment) {···
            var value = comment.value;

            // cutout exceptions
            allExcept.forEach(function(el) {
                if (value.indexOf(el) === 0) {
                    value = value.substr(el.length);
                }
            });

            if (value.length === 0) {
                return;
            }

            if (value[0] !== ' ') {
                errors.add('Missing space after line comment', comment.loc.start);
            }
        });
        file.iterateTokensByType('Line', function(comment) {
            var value = comment.value;
            // cutout exceptions
Function (anonymous_863)
✓ Was called            allExcept.forEach(function(el) {···
                if (value.indexOf(el) === 0) {
                    value = value.substr(el.length);
                }
            });
            allExcept.forEach(function(el) {
Branch IfStatement
✓ Positive was executed (if)                if (value.indexOf(el) === 0) {···
                    value = value.substr(el.length);
                }
✓ Negative was executed (else)                }···
            });
                if (value.indexOf(el) === 0) {
                    value = value.substr(el.length);
                }
            });
Branch IfStatement
✓ Positive was executed (if)            if (value.length === 0) {···
                return;
            }
✓ Negative was executed (else)            }···

            if (value[0] !== ' ') {
            if (value.length === 0) {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (value[0] !== ' ') {···
                errors.add('Missing space after line comment', comment.loc.start);
            }
✓ Negative was executed (else)            }···
        });
            if (value[0] !== ' ') {
                errors.add('Missing space after line comment', comment.loc.start);
            }
        });
    }
};

disallow-space-after-line-comment.js
/**
 * Requires that a line comment (`//`) not be followed by a space.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowSpaceAfterLineComment": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * //A comment
 * /* A comment*\/
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * // A comment
 * ```
 */
var assert = require('assert');
Function (anonymous_864)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_865)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_866)
✓ Was called    getOptionName: function() {···
        return 'disallowSpaceAfterLineComment';
    },
    getOptionName: function() {
        return 'disallowSpaceAfterLineComment';
    },
Function (anonymous_867)
✓ Was called    check: function(file, errors) {···
        file.iterateTokensByType('Line', function(comment) {
            var value = comment.value;
            if (value.length > 0 && value[0] === ' ') {
                errors.add('Illegal space after line comment', comment.loc.start);
            }
        });
    }
    check: function(file, errors) {
Function (anonymous_868)
✓ Was called        file.iterateTokensByType('Line', function(comment) {···
            var value = comment.value;
            if (value.length > 0 && value[0] === ' ') {
                errors.add('Illegal space after line comment', comment.loc.start);
            }
        });
        file.iterateTokensByType('Line', function(comment) {
            var value = comment.value;
Branch IfStatement
✓ Positive was executed (if)            if (value.length > 0 && value[0] === ' ') {···
                errors.add('Illegal space after line comment', comment.loc.start);
            }
✓ Negative was executed (else)            }···
        });
Branch LogicalExpression
✓ Was returned            if (value.length > 0 && value[0] === ' ') {
✓ Was returned            if (value.length > 0 && value[0] === ' ') {
            if (value.length > 0 && value[0] === ' ') {
                errors.add('Illegal space after line comment', comment.loc.start);
            }
        });
    }
};

require-anonymous-functions.js
/**
 * Requires that a function expression be anonymous.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "requireAnonymousFunctions": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var a = function(){
 *
 * };
 *
 * $('#foo').click(function(){
 *
 * })
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var a = function foo(){
 *
 * };
 *
 * $('#foo').click(function bar(){
 *
 * });
 * ```
 */
var assert = require('assert');
Function (anonymous_869)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_870)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_871)
✓ Was called    getOptionName: function() {···
        return 'requireAnonymousFunctions';
    },
    getOptionName: function() {
        return 'requireAnonymousFunctions';
    },
Function (anonymous_872)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType(['FunctionExpression', 'FunctionDeclaration'], function(node) {
            if (node.id !== null) {
                errors.add('Functions must not be named', node.loc.start);
            }
        });
    }
    check: function(file, errors) {
Function (anonymous_873)
✓ Was called        file.iterateNodesByType(['FunctionExpression', 'FunctionDeclaration'], function(node) {···
            if (node.id !== null) {
                errors.add('Functions must not be named', node.loc.start);
            }
        });
        file.iterateNodesByType(['FunctionExpression', 'FunctionDeclaration'], function(node) {
Branch IfStatement
✓ Positive was executed (if)            if (node.id !== null) {···
                errors.add('Functions must not be named', node.loc.start);
            }
✓ Negative was executed (else)            }···
        });
            if (node.id !== null) {
                errors.add('Functions must not be named', node.loc.start);
            }
        });
    }
};

disallow-anonymous-functions.js
/**
 * Requires that a function expression be named.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowAnonymousFunctions": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var a = function foo(){
 *
 * };
 *
 * $('#foo').click(function bar(){
 *
 * });
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var a = function(){
 *
 * };
 *
 * $('#foo').click(function(){
 *
 * });
 * ```
 */
var assert = require('assert');
Function (anonymous_874)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_875)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_876)
✓ Was called    getOptionName: function() {···
        return 'disallowAnonymousFunctions';
    },
    getOptionName: function() {
        return 'disallowAnonymousFunctions';
    },
Function (anonymous_877)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType(['FunctionExpression', 'FunctionDeclaration'], function(node) {
            if (node.id === null) {
                errors.add('Anonymous functions need to be named', node.loc.start);
            }
        });
    }
    check: function(file, errors) {
Function (anonymous_878)
✓ Was called        file.iterateNodesByType(['FunctionExpression', 'FunctionDeclaration'], function(node) {···
            if (node.id === null) {
                errors.add('Anonymous functions need to be named', node.loc.start);
            }
        });
        file.iterateNodesByType(['FunctionExpression', 'FunctionDeclaration'], function(node) {
Branch IfStatement
✓ Positive was executed (if)            if (node.id === null) {···
                errors.add('Anonymous functions need to be named', node.loc.start);
            }
✓ Negative was executed (else)            }···
        });
            if (node.id === null) {
                errors.add('Anonymous functions need to be named', node.loc.start);
            }
        });
    }
};

require-named-unassigned-functions.js
/**
 * Require unassigned functions to be named inline
 *
 * Types: `Boolean` or `Object`
 *
 * Values:
 *  - `true`
 *  - `Object`:
 *     - `allExcept`: array of quoted identifiers
 *
 * #### Example
 *
 * ```js
 * "requireNamedUnassignedFunctions": { "allExcept": ["describe", "it"] }
 * ```
 *
 * ##### Valid
 *
 * ```js
 * [].forEach(function x() {});
 * var y = function() {};
 * function z() {}
 * it(function () {});
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * [].forEach(function () {});
 * before(function () {});
 * ```
 */
var assert = require('assert');
var pathval = require('pathval');
Function getNodeName
✓ Was calledfunction getNodeName(node) {···
    if (node.type === 'Identifier') {
        return node.name;
    } else {
        return node.value;
    }
}
function getNodeName(node) {
Branch IfStatement
✓ Positive was executed (if)    if (node.type === 'Identifier') {···
        return node.name;
    } else {
✓ Negative was executed (else)    } else {···
        return node.value;
    }
    if (node.type === 'Identifier') {
        return node.name;
    } else {
        return node.value;
    }
}
Function (anonymous_880)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_881)
✓ Was called    configure: function(options) {···
        assert(
            options === true ||
            typeof options === 'object',
            this.getOptionName() + ' option requires true value ' +
            'or an object with String[] `allExcept` property'
        );

        // verify first item in `allExcept` property in object (if it's an object)
        assert(
            typeof options !== 'object' ||
            Array.isArray(options.allExcept) &&
            typeof options.allExcept[0] === 'string',
            'Property `allExcept` in ' + this.getOptionName() + ' should be an array of strings'
        );

        if (options.allExcept) {
            this._allExceptItems = options.allExcept.map(function(item) {
                var parts = pathval.parse(item).map(function extractPart (part) {
                    return part.i !== undefined ? part.i : part.p;
                });
                return JSON.stringify(parts);
            });
        }
    },
    configure: function(options) {
        assert(
Branch LogicalExpression
✓ Was returned            typeof options === 'object',
✓ Was returned            options === true ||
            options === true ||
            typeof options === 'object',
            this.getOptionName() + ' option requires true value ' +
            'or an object with String[] `allExcept` property'
        );
        // verify first item in `allExcept` property in object (if it's an object)
        assert(
Branch LogicalExpression
✓ Was returned            Array.isArray(options.allExcept) &&···
            typeof options.allExcept[0] === 'string',
✓ Was returned            typeof options !== 'object' ||
            typeof options !== 'object' ||
Branch LogicalExpression
✓ Was returned            typeof options.allExcept[0] === 'string',
✓ Was returned            Array.isArray(options.allExcept) &&
            Array.isArray(options.allExcept) &&
            typeof options.allExcept[0] === 'string',
            'Property `allExcept` in ' + this.getOptionName() + ' should be an array of strings'
        );
Branch IfStatement
✓ Positive was executed (if)        if (options.allExcept) {···
            this._allExceptItems = options.allExcept.map(function(item) {
                var parts = pathval.parse(item).map(function extractPart (part) {
                    return part.i !== undefined ? part.i : part.p;
                });
                return JSON.stringify(parts);
            });
        }
✓ Negative was executed (else)        }···
    },
        if (options.allExcept) {
Function (anonymous_882)
✓ Was called            this._allExceptItems = options.allExcept.map(function(item) {···
                var parts = pathval.parse(item).map(function extractPart (part) {
                    return part.i !== undefined ? part.i : part.p;
                });
                return JSON.stringify(parts);
            });
            this._allExceptItems = options.allExcept.map(function(item) {
Function extractPart
✓ Was called                var parts = pathval.parse(item).map(function extractPart (part) {···
                    return part.i !== undefined ? part.i : part.p;
                });
                var parts = pathval.parse(item).map(function extractPart (part) {
Branch ConditionalExpression
✓ Positive was returned (? ...)                    return part.i !== undefined ? part.i : part.p;
✓ Negative was returned (: ...)                    return part.i !== undefined ? part.i : part.p;
                    return part.i !== undefined ? part.i : part.p;
                });
                return JSON.stringify(parts);
            });
        }
    },
Function (anonymous_884)
✓ Was called    getOptionName: function() {···
        return 'requireNamedUnassignedFunctions';
    },
    getOptionName: function() {
        return 'requireNamedUnassignedFunctions';
    },
Function (anonymous_885)
✓ Was called    check: function(file, errors) {···
        var _this = this;
        file.iterateNodesByType('FunctionExpression', function(node) {
            var parentNode = node.parentNode;
            // If the function has been named via left hand assignment, skip it
            //   e.g. `var hello = function() {`, `foo.bar = function() {`
            if (parentNode.type.match(/VariableDeclarator|Property|AssignmentExpression/)) {
                return;
            }

            // If the function has been named, skip it
            //   e.g. `[].forEach(function hello() {`
            if (node.id !== null) {
                return;
            }

            // If we have exceptions and the function is being invoked, detect whether we excepted it
            if (_this._allExceptItems && parentNode.type === 'CallExpression') {
                // Determine the path that resolves to our call expression
                // We must cover both direct calls (e.g. `it(function() {`) and
                //   member expressions (e.g. `foo.bar(function() {`)
                var memberNode = parentNode.callee;
                var canBeRepresented = true;
                var fullpathParts = [];
                while (memberNode) {
                    if (memberNode.type.match(/Identifier|Literal/)) {
                        fullpathParts.unshift(getNodeName(memberNode));
                    } else if (memberNode.type === 'MemberExpression') {
                        fullpathParts.unshift(getNodeName(memberNode.property));
                    } else {
                        canBeRepresented = false;
                        break;
                    }
                    memberNode = memberNode.object;
                }

                // If the path is not-dynamic (i.e. can be represented by static parts),
                //   then check it against our exceptions
                if (canBeRepresented) {
                    var fullpath = JSON.stringify(fullpathParts);
                    for (var i = 0, l = _this._allExceptItems.length; i < l; i++) {
                        if (fullpath === _this._allExceptItems[i]) {
                            return;
                        }
                    }
                }
            }

            // Complain that this function must be named
            errors.add('Inline functions need to be named', node.loc.start);
        });
    }
    check: function(file, errors) {
        var _this = this;
Function (anonymous_886)
✓ Was called        file.iterateNodesByType('FunctionExpression', function(node) {···
            var parentNode = node.parentNode;
            // If the function has been named via left hand assignment, skip it
            //   e.g. `var hello = function() {`, `foo.bar = function() {`
            if (parentNode.type.match(/VariableDeclarator|Property|AssignmentExpression/)) {
                return;
            }

            // If the function has been named, skip it
            //   e.g. `[].forEach(function hello() {`
            if (node.id !== null) {
                return;
            }

            // If we have exceptions and the function is being invoked, detect whether we excepted it
            if (_this._allExceptItems && parentNode.type === 'CallExpression') {
                // Determine the path that resolves to our call expression
                // We must cover both direct calls (e.g. `it(function() {`) and
                //   member expressions (e.g. `foo.bar(function() {`)
                var memberNode = parentNode.callee;
                var canBeRepresented = true;
                var fullpathParts = [];
                while (memberNode) {
                    if (memberNode.type.match(/Identifier|Literal/)) {
                        fullpathParts.unshift(getNodeName(memberNode));
                    } else if (memberNode.type === 'MemberExpression') {
                        fullpathParts.unshift(getNodeName(memberNode.property));
                    } else {
                        canBeRepresented = false;
                        break;
                    }
                    memberNode = memberNode.object;
                }

                // If the path is not-dynamic (i.e. can be represented by static parts),
                //   then check it against our exceptions
                if (canBeRepresented) {
                    var fullpath = JSON.stringify(fullpathParts);
                    for (var i = 0, l = _this._allExceptItems.length; i < l; i++) {
                        if (fullpath === _this._allExceptItems[i]) {
                            return;
                        }
                    }
                }
            }

            // Complain that this function must be named
            errors.add('Inline functions need to be named', node.loc.start);
        });
        file.iterateNodesByType('FunctionExpression', function(node) {
            var parentNode = node.parentNode;
            // If the function has been named via left hand assignment, skip it
            //   e.g. `var hello = function() {`, `foo.bar = function() {`
Branch IfStatement
✓ Positive was executed (if)            if (parentNode.type.match(/VariableDeclarator|Property|AssignmentExpression/)) {···
                return;
            }
✓ Negative was executed (else)            }···

            // If the function has been named, skip it
            if (parentNode.type.match(/VariableDeclarator|Property|AssignmentExpression/)) {
                return;
            }
            // If the function has been named, skip it
            //   e.g. `[].forEach(function hello() {`
Branch IfStatement
✓ Positive was executed (if)            if (node.id !== null) {···
                return;
            }
✓ Negative was executed (else)            }···

            // If we have exceptions and the function is being invoked, detect whether we excepted it
            if (node.id !== null) {
                return;
            }
            // If we have exceptions and the function is being invoked, detect whether we excepted it
Branch IfStatement
✓ Positive was executed (if)            if (_this._allExceptItems && parentNode.type === 'CallExpression') {···
                // Determine the path that resolves to our call expression
                // We must cover both direct calls (e.g. `it(function() {`) and
                //   member expressions (e.g. `foo.bar(function() {`)
                var memberNode = parentNode.callee;
                var canBeRepresented = true;
                var fullpathParts = [];
                while (memberNode) {
                    if (memberNode.type.match(/Identifier|Literal/)) {
                        fullpathParts.unshift(getNodeName(memberNode));
                    } else if (memberNode.type === 'MemberExpression') {
                        fullpathParts.unshift(getNodeName(memberNode.property));
                    } else {
                        canBeRepresented = false;
                        break;
                    }
                    memberNode = memberNode.object;
                }

                // If the path is not-dynamic (i.e. can be represented by static parts),
                //   then check it against our exceptions
                if (canBeRepresented) {
                    var fullpath = JSON.stringify(fullpathParts);
                    for (var i = 0, l = _this._allExceptItems.length; i < l; i++) {
                        if (fullpath === _this._allExceptItems[i]) {
                            return;
                        }
                    }
                }
            }
✓ Negative was executed (else)            }···

            // Complain that this function must be named
Branch LogicalExpression
✓ Was returned            if (_this._allExceptItems && parentNode.type === 'CallExpression') {
✓ Was returned            if (_this._allExceptItems && parentNode.type === 'CallExpression') {
            if (_this._allExceptItems && parentNode.type === 'CallExpression') {
                // Determine the path that resolves to our call expression
                // We must cover both direct calls (e.g. `it(function() {`) and
                //   member expressions (e.g. `foo.bar(function() {`)
                var memberNode = parentNode.callee;
                var canBeRepresented = true;
                var fullpathParts = [];
                while (memberNode) {
Branch IfStatement
✓ Positive was executed (if)                    if (memberNode.type.match(/Identifier|Literal/)) {···
                        fullpathParts.unshift(getNodeName(memberNode));
                    } else if (memberNode.type === 'MemberExpression') {
✓ Negative was executed (else)                    } else if (memberNode.type === 'MemberExpression') {···
                        fullpathParts.unshift(getNodeName(memberNode.property));
                    } else {
                        canBeRepresented = false;
                        break;
                    }
                    if (memberNode.type.match(/Identifier|Literal/)) {
                        fullpathParts.unshift(getNodeName(memberNode));
Branch IfStatement
✓ Positive was executed (if)                    } else if (memberNode.type === 'MemberExpression') {···
                        fullpathParts.unshift(getNodeName(memberNode.property));
                    } else {
✓ Negative was executed (else)                    } else {···
                        canBeRepresented = false;
                        break;
                    }
                    } else if (memberNode.type === 'MemberExpression') {
                        fullpathParts.unshift(getNodeName(memberNode.property));
                    } else {
                        canBeRepresented = false;
                        break;
                    }
                    memberNode = memberNode.object;
                }
                // If the path is not-dynamic (i.e. can be represented by static parts),
                //   then check it against our exceptions
Branch IfStatement
✓ Positive was executed (if)                if (canBeRepresented) {···
                    var fullpath = JSON.stringify(fullpathParts);
                    for (var i = 0, l = _this._allExceptItems.length; i < l; i++) {
                        if (fullpath === _this._allExceptItems[i]) {
                            return;
                        }
                    }
                }
✓ Negative was executed (else)                }···
            }
                if (canBeRepresented) {
                    var fullpath = JSON.stringify(fullpathParts);
                    for (var i = 0, l = _this._allExceptItems.length; i < l; i++) {
Branch IfStatement
✓ Positive was executed (if)                        if (fullpath === _this._allExceptItems[i]) {···
                            return;
                        }
✓ Negative was executed (else)                        }···
                    }
                        if (fullpath === _this._allExceptItems[i]) {
                            return;
                        }
                    }
                }
            }
            // Complain that this function must be named
            errors.add('Inline functions need to be named', node.loc.start);
        });
    }
};

disallow-named-unassigned-functions.js
/**
 * Disallows unassigned functions to be named inline
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowNamedUnassignedFunctions": true
 * ```
 *
 * ##### Valid
 * ```js
 * [].forEach(function () {});
 * var x = function() {};
 * function y() {}
 * ```
 *
 * ##### Invalid
 * ```js
 * [].forEach(function x() {});
 * ```
 */
var assert = require('assert');
Function (anonymous_887)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_888)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires true value'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires true value'
        );
    },
Function (anonymous_889)
✓ Was called    getOptionName: function() {···
        return 'disallowNamedUnassignedFunctions';
    },
    getOptionName: function() {
        return 'disallowNamedUnassignedFunctions';
    },
Function (anonymous_890)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('FunctionExpression', function(node) {
            // If the function has been named via left hand assignment, skip it
            //   e.g. `var hello = function() {`, `foo.bar = function() {`
            if (node.parentNode.type.match(/VariableDeclarator|Property|AssignmentExpression/)) {
                return;
            }

            // If the function has not been named, skip it
            //   e.g. `[].forEach(function() {`
            if (node.id === null) {
                return;
            }

            // Otherwise, complain that it is being named
            errors.add('Inline functions cannot be named', node.loc.start);
        });
    }
    check: function(file, errors) {
Function (anonymous_891)
✓ Was called        file.iterateNodesByType('FunctionExpression', function(node) {···
            // If the function has been named via left hand assignment, skip it
            //   e.g. `var hello = function() {`, `foo.bar = function() {`
            if (node.parentNode.type.match(/VariableDeclarator|Property|AssignmentExpression/)) {
                return;
            }

            // If the function has not been named, skip it
            //   e.g. `[].forEach(function() {`
            if (node.id === null) {
                return;
            }

            // Otherwise, complain that it is being named
            errors.add('Inline functions cannot be named', node.loc.start);
        });
        file.iterateNodesByType('FunctionExpression', function(node) {
            // If the function has been named via left hand assignment, skip it
            //   e.g. `var hello = function() {`, `foo.bar = function() {`
Branch IfStatement
✓ Positive was executed (if)            if (node.parentNode.type.match(/VariableDeclarator|Property|AssignmentExpression/)) {···
                return;
            }
✓ Negative was executed (else)            }···

            // If the function has not been named, skip it
            if (node.parentNode.type.match(/VariableDeclarator|Property|AssignmentExpression/)) {
                return;
            }
            // If the function has not been named, skip it
            //   e.g. `[].forEach(function() {`
Branch IfStatement
✓ Positive was executed (if)            if (node.id === null) {···
                return;
            }
✓ Negative was executed (else)            }···

            // Otherwise, complain that it is being named
            if (node.id === null) {
                return;
            }
            // Otherwise, complain that it is being named
            errors.add('Inline functions cannot be named', node.loc.start);
        });
    }
};

require-function-declarations.js
/**
 * Requires function declarations by disallowing assignment of functions
 * expressions to variables. Function expressions are allowed in all other
 * contexts, including when passed as function arguments or immediately invoked.
 *
 * Assignment of function expressions to object members is also permitted, since
 * these can't be declared.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "requireFunctionDeclarations": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * function declared() {
 *
 * };
 *
 * (function iife() {
 *     void 0;
 * })();
 *
 * var obj = {
 *     a: function () {}
 * };
 *
 * obj.b = function () { };
 *
 * $('#foo').click(function bar() {
 *
 * };)
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var expressed = function() {
 *
 * };
 *
 * var expressed = function deeply() {
 *
 * };
 * ```
 */
var assert = require('assert');
Function (anonymous_892)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_893)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_894)
✓ Was called    getOptionName: function() {···
        return 'requireFunctionDeclarations';
    },
    getOptionName: function() {
        return 'requireFunctionDeclarations';
    },
Function (anonymous_895)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType(
            'VariableDeclarator',
            function(node) {
                if (node.init && node.init.type === 'FunctionExpression') {
                    errors.add('Use a function declaration instead', node.loc.start);
                }
            }
        );

        file.iterateNodesByType(
            'AssignmentExpression',
            function(node) {
                if (node.left.type !== 'MemberExpression' &&
                    node.right.type === 'FunctionExpression') {
                    errors.add('Use a function declaration instead', node.loc.start);
                }
            }
        );
    }
    check: function(file, errors) {
        file.iterateNodesByType(
            'VariableDeclarator',
Function (anonymous_896)
✓ Was called            function(node) {···
                if (node.init && node.init.type === 'FunctionExpression') {
                    errors.add('Use a function declaration instead', node.loc.start);
                }
            }
            function(node) {
Branch IfStatement
✓ Positive was executed (if)                if (node.init && node.init.type === 'FunctionExpression') {···
                    errors.add('Use a function declaration instead', node.loc.start);
                }
✓ Negative was executed (else)                }···
            }
Branch LogicalExpression
✓ Was returned                if (node.init && node.init.type === 'FunctionExpression') {
✓ Was returned                if (node.init && node.init.type === 'FunctionExpression') {
                if (node.init && node.init.type === 'FunctionExpression') {
                    errors.add('Use a function declaration instead', node.loc.start);
                }
            }
        );
        file.iterateNodesByType(
            'AssignmentExpression',
Function (anonymous_897)
✓ Was called            function(node) {···
                if (node.left.type !== 'MemberExpression' &&
                    node.right.type === 'FunctionExpression') {
                    errors.add('Use a function declaration instead', node.loc.start);
                }
            }
            function(node) {
Branch IfStatement
✓ Positive was executed (if)                    node.right.type === 'FunctionExpression') {···
                    errors.add('Use a function declaration instead', node.loc.start);
                }
✓ Negative was executed (else)                }···
            }
Branch LogicalExpression
✓ Was returned                    node.right.type === 'FunctionExpression') {
✓ Was returned                if (node.left.type !== 'MemberExpression' &&
                if (node.left.type !== 'MemberExpression' &&
                    node.right.type === 'FunctionExpression') {
                    errors.add('Use a function declaration instead', node.loc.start);
                }
            }
        );
    }
};

disallow-function-declarations.js
/**
 * Disallows function declarations.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowFunctionDeclarations": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var expressed = function() {
 *
 * };
 *
 * var expressed = function deeply() {
 *
 * };
 *
 * $('#foo').click(function bar() {
 *
 * };)
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * function stated() {
 *
 * }
 * ```
 */
var assert = require('assert');
Function (anonymous_898)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_899)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_900)
✓ Was called    getOptionName: function() {···
        return 'disallowFunctionDeclarations';
    },
    getOptionName: function() {
        return 'disallowFunctionDeclarations';
    },
Function (anonymous_901)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('FunctionDeclaration', function(node) {
            errors.add('Illegal function declaration', node.loc.start);
        });
    }
    check: function(file, errors) {
Function (anonymous_902)
✓ Was called        file.iterateNodesByType('FunctionDeclaration', function(node) {···
            errors.add('Illegal function declaration', node.loc.start);
        });
        file.iterateNodesByType('FunctionDeclaration', function(node) {
            errors.add('Illegal function declaration', node.loc.start);
        });
    }
};

require-capitalized-comments.js
/**
 * Requires the first alphabetical character of a comment to be uppercase, unless it is part of a multi-line textblock.
 *
 * By default, the prefix for inline comments `jscs` is ignored.
 *
 * Types: `Boolean` or `Object`
 *
 * Values:
 *  - `true`
 *  - `Object`:
 *     - `allExcept`: array of quoted exceptions
 *
 * #### Example
 *
 * `"requireCapitalizedComments": true`
 *
 * Valid:
 *
 * ```
 * // Valid
 * //Valid
 *
 * /*
 *   Valid
 *  *\/
 *
 * /**
 *  * Valid
 *  *\/
 *
 * // A textblock is a set of lines
 * // that starts with a capitalized letter
 * // and has one or more non-capitalized lines
 * // afterwards
 *
 * // A textblock may also have multiple lines.
 * // Those lines can be uppercase as well to support
 * // sentense breaks in textblocks
 *
 * // 123 or any non-alphabetical starting character
 * // @are also valid anywhere
 * ```
 *
 * Invalid:
 * ```
 * // invalid
 * //invalid
 * /** invalid *\/
 * /**
 *  * invalid
 *  *\/
 * ```
 *
 * ```js
 * "requireCapitalizedComments": { "allExcept": ["jshint"] }
 * ```
 *
 * Valid:
 *
 * ```
 * function sayHello() {
 *     \/* jshint: -W071 *\/
 *
 *     // I can now say hello in lots of statements, if I like.
 *     return "Hello";
 * }
 * ```
 *
 * * Invalid:
 *
 * ```
 * function sayHello() {
 *     \/* jshint: -W071 *\/
 *
 *     // i can now say hello in lots of statements, if I like.
 *     return "Hello";
 * }
 * ```
 *
 * * Invalid:
 *
 * ```
 * function sayHello() {
 *     \/* istanbul ignore next *\/
 *
 *     // I'd like to ignore this statement in coverage reports.
 *     return "Hello";
 * }
 * ```
 *
 */
var assert = require('assert');
Function (anonymous_903)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_904)
✓ Was called    configure: function(options) {···
        // except comments that begin with `jscs`, since these are used to
        // selectively enable/disable rules within a file
        this._exceptions = {
            'jscs': true
        };

        var optionName = this.getOptionName();

        var isObject = typeof options === 'object';

        assert(
            options === true ||
            isObject,
            optionName + ' option requires a true value ' +
            'or an object with String[] `allExcept` property'
        );

        if (isObject) {
            var exceptions = options.allExcept;

            // verify items in `allExcept` property in object are string values
            assert(
                Array.isArray(exceptions) &&
                exceptions.every(function(el) { return typeof el === 'string'; }),
                'Property `allExcept` in ' + optionName + ' should be an array of strings'
            );

            for (var i = 0, l = exceptions.length; i < l; i++) {
                this._exceptions[exceptions[i]] = true;
            }
        }
    },
    configure: function(options) {
        // except comments that begin with `jscs`, since these are used to
        // selectively enable/disable rules within a file
        this._exceptions = {
            'jscs': true
        };
        var optionName = this.getOptionName();
        var isObject = typeof options === 'object';
        assert(
Branch LogicalExpression
✓ Was returned            isObject,
✓ Was returned            options === true ||
            options === true ||
            isObject,
            optionName + ' option requires a true value ' +
            'or an object with String[] `allExcept` property'
        );
Branch IfStatement
✓ Positive was executed (if)        if (isObject) {···
            var exceptions = options.allExcept;

            // verify items in `allExcept` property in object are string values
            assert(
                Array.isArray(exceptions) &&
                exceptions.every(function(el) { return typeof el === 'string'; }),
                'Property `allExcept` in ' + optionName + ' should be an array of strings'
            );

            for (var i = 0, l = exceptions.length; i < l; i++) {
                this._exceptions[exceptions[i]] = true;
            }
        }
✓ Negative was executed (else)        }···
    },
        if (isObject) {
            var exceptions = options.allExcept;
            // verify items in `allExcept` property in object are string values
            assert(
Branch LogicalExpression
✓ Was returned                exceptions.every(function(el) { return typeof el === 'string'; }),
✗ Was not returned                Array.isArray(exceptions) &&
                Array.isArray(exceptions) &&
Function (anonymous_905)
✓ Was called                exceptions.every(function(el) { return typeof el === 'string'; }),
                exceptions.every(function(el) { return typeof el === 'string'; }),
                'Property `allExcept` in ' + optionName + ' should be an array of strings'
            );
            for (var i = 0, l = exceptions.length; i < l; i++) {
                this._exceptions[exceptions[i]] = true;
            }
        }
    },
Function (anonymous_906)
✓ Was called    getOptionName: function() {···
        return 'requireCapitalizedComments';
    },
    getOptionName: function() {
        return 'requireCapitalizedComments';
    },
Function (anonymous_907)
✓ Was called    check: function(file, errors) {···
        var inTextBlock = null;
        var exceptions = this._exceptions;

        var letterPattern = require('../../patterns/L');
        var upperCasePattern = require('../../patterns/Lu');

        file.iterateTokensByType(['Line', 'Block'], function(comment, index, comments) {
            // strip leading whitespace and any asterisks
            // split on whitespace and colons
            var splitComment = comment.value.replace(/(^\s+|[\*])/g, '').split(/[\s\:]/g);

            if (exceptions[splitComment[0]]) {
                return;
            }

            var stripped = comment.value.replace(/[\n\s\*]/g, '');
            var firstChar = stripped[0];
            var isLetter = firstChar && letterPattern.test(firstChar);

            if (!isLetter) {
                inTextBlock = false;
                return;
            }

            inTextBlock = inTextBlock &&
                comments[index - 1].type === 'Line' &&
                comments[index - 1].loc.start.line + 1 === comment.loc.start.line;

            var isUpperCase = upperCasePattern.test(firstChar);
            var isValid = isUpperCase || inTextBlock;

            if (!isValid) {
                errors.add(
                    'Comments must start with an uppercase letter, unless it is part of a textblock',
                    comment.loc.start
                );
            }

            inTextBlock = comment.type === 'Line';
        });
    }
    check: function(file, errors) {
        var inTextBlock = null;
        var exceptions = this._exceptions;
        var letterPattern = require('../../patterns/L');
        var upperCasePattern = require('../../patterns/Lu');
Function (anonymous_908)
✓ Was called        file.iterateTokensByType(['Line', 'Block'], function(comment, index, comments) {···
            // strip leading whitespace and any asterisks
            // split on whitespace and colons
            var splitComment = comment.value.replace(/(^\s+|[\*])/g, '').split(/[\s\:]/g);

            if (exceptions[splitComment[0]]) {
                return;
            }

            var stripped = comment.value.replace(/[\n\s\*]/g, '');
            var firstChar = stripped[0];
            var isLetter = firstChar && letterPattern.test(firstChar);

            if (!isLetter) {
                inTextBlock = false;
                return;
            }

            inTextBlock = inTextBlock &&
                comments[index - 1].type === 'Line' &&
                comments[index - 1].loc.start.line + 1 === comment.loc.start.line;

            var isUpperCase = upperCasePattern.test(firstChar);
            var isValid = isUpperCase || inTextBlock;

            if (!isValid) {
                errors.add(
                    'Comments must start with an uppercase letter, unless it is part of a textblock',
                    comment.loc.start
                );
            }

            inTextBlock = comment.type === 'Line';
        });
        file.iterateTokensByType(['Line', 'Block'], function(comment, index, comments) {
            // strip leading whitespace and any asterisks
            // split on whitespace and colons
            var splitComment = comment.value.replace(/(^\s+|[\*])/g, '').split(/[\s\:]/g);
Branch IfStatement
✓ Positive was executed (if)            if (exceptions[splitComment[0]]) {···
                return;
            }
✓ Negative was executed (else)            }···

            var stripped = comment.value.replace(/[\n\s\*]/g, '');
            if (exceptions[splitComment[0]]) {
                return;
            }
            var stripped = comment.value.replace(/[\n\s\*]/g, '');
            var firstChar = stripped[0];
Branch LogicalExpression
✓ Was returned            var isLetter = firstChar && letterPattern.test(firstChar);
✓ Was returned            var isLetter = firstChar && letterPattern.test(firstChar);
            var isLetter = firstChar && letterPattern.test(firstChar);
Branch IfStatement
✓ Positive was executed (if)            if (!isLetter) {···
                inTextBlock = false;
                return;
            }
✓ Negative was executed (else)            }···

            inTextBlock = inTextBlock &&
            if (!isLetter) {
                inTextBlock = false;
                return;
            }
Branch LogicalExpression
✓ Was returned                comments[index - 1].loc.start.line + 1 === comment.loc.start.line;
✓ Was returned            inTextBlock = inTextBlock &&···
                comments[index - 1].type === 'Line' &&
Branch LogicalExpression
✓ Was returned                comments[index - 1].type === 'Line' &&
✓ Was returned            inTextBlock = inTextBlock &&
            inTextBlock = inTextBlock &&
                comments[index - 1].type === 'Line' &&
                comments[index - 1].loc.start.line + 1 === comment.loc.start.line;
            var isUpperCase = upperCasePattern.test(firstChar);
Branch LogicalExpression
✓ Was returned            var isValid = isUpperCase || inTextBlock;
✓ Was returned            var isValid = isUpperCase || inTextBlock;
            var isValid = isUpperCase || inTextBlock;
Branch IfStatement
✓ Positive was executed (if)            if (!isValid) {···
                errors.add(
                    'Comments must start with an uppercase letter, unless it is part of a textblock',
                    comment.loc.start
                );
            }
✓ Negative was executed (else)            }···

            inTextBlock = comment.type === 'Line';
            if (!isValid) {
                errors.add(
                    'Comments must start with an uppercase letter, unless it is part of a textblock',
                    comment.loc.start
                );
            }
            inTextBlock = comment.type === 'Line';
        });
    }
};

disallow-capitalized-comments.js
/**
 * Requires the first alphabetical character of a comment to be lowercase.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * `"disallowCapitalizedComments": true`
 *
 * Valid:
 *
 * ```
 * // valid
 * //valid
 *
 * /*
 *   valid
 *  *\/
 *
 * /**
 *  * valid
 *  *\/
 *
 * // 123 or any non-alphabetical starting character
 * ```
 *
 * Invalid:
 * ```
 * // Invalid
 * //Invalid
 * /** Invalid *\/
 * /**
 *  * Invalid
 *  *\/
 * ```
 */
var assert = require('assert');
Function (anonymous_909)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_910)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_911)
✓ Was called    getOptionName: function() {···
        return 'disallowCapitalizedComments';
    },
    getOptionName: function() {
        return 'disallowCapitalizedComments';
    },
Function (anonymous_912)
✓ Was called    check: function(file, errors) {···
        var letterPattern = require('../../patterns/L');
        var lowerCasePattern = require('../../patterns/Ll');

        file.iterateTokensByType(['Line', 'Block'], function(comment) {
            var stripped = comment.value.replace(/[\n\s\*]/g, '');
            var firstChar = stripped[0];

            if (letterPattern.test(firstChar) && !lowerCasePattern.test(firstChar)) {
                errors.add(
                    'Comments must start with a lowercase letter',
                    comment.loc.start
                );
            }
        });
    }
    check: function(file, errors) {
        var letterPattern = require('../../patterns/L');
        var lowerCasePattern = require('../../patterns/Ll');
Function (anonymous_913)
✓ Was called        file.iterateTokensByType(['Line', 'Block'], function(comment) {···
            var stripped = comment.value.replace(/[\n\s\*]/g, '');
            var firstChar = stripped[0];

            if (letterPattern.test(firstChar) && !lowerCasePattern.test(firstChar)) {
                errors.add(
                    'Comments must start with a lowercase letter',
                    comment.loc.start
                );
            }
        });
        file.iterateTokensByType(['Line', 'Block'], function(comment) {
            var stripped = comment.value.replace(/[\n\s\*]/g, '');
            var firstChar = stripped[0];
Branch IfStatement
✓ Positive was executed (if)            if (letterPattern.test(firstChar) && !lowerCasePattern.test(firstChar)) {···
                errors.add(
                    'Comments must start with a lowercase letter',
                    comment.loc.start
                );
            }
✓ Negative was executed (else)            }···
        });
Branch LogicalExpression
✓ Was returned            if (letterPattern.test(firstChar) && !lowerCasePattern.test(firstChar)) {
✓ Was returned            if (letterPattern.test(firstChar) && !lowerCasePattern.test(firstChar)) {
            if (letterPattern.test(firstChar) && !lowerCasePattern.test(firstChar)) {
                errors.add(
                    'Comments must start with a lowercase letter',
                    comment.loc.start
                );
            }
        });
    }
};

require-line-break-after-variable-assignment.js
/**
 * Requires placing line feed after assigning a variable.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "requireLineBreakAfterVariableAssignment": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var abc = 8;
 * var foo = 5;
 *
 * var a, b, c,
 *     foo = 7,
 *     bar = 8;
 *
 * var a,
 *     foo = 7,
 *     a, b, c,
 *     bar = 8;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var abc = 8; var foo = 5;
 *
 * var a, b, c,
 *     foo = 7, bar = 8;
 * ```
 */
var assert = require('assert');
Function (anonymous_914)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_915)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_916)
✓ Was called    getOptionName: function() {···
        return 'requireLineBreakAfterVariableAssignment';
    },
    getOptionName: function() {
        return 'requireLineBreakAfterVariableAssignment';
    },
Function (anonymous_917)
✓ Was called    check: function(file, errors) {···
        var lastDeclaration;
        file.iterateNodesByType('VariableDeclaration', function(node) {
            if (node.parentNode.type === 'ForStatement' ||
                node.parentNode.type === 'ForInStatement' ||
                node.parentNode.type === 'ForOfStatement') {
                return;
            }

            for (var i = 0; i < node.declarations.length; i++) {
                var thisDeclaration = node.declarations[i];
                if (thisDeclaration.parentNode.kind === 'var' ||
                    thisDeclaration.parentNode.kind === 'let' ||
                    thisDeclaration.parentNode.kind === 'const') {
                    if (lastDeclaration && lastDeclaration.init) {
                        errors.assert.differentLine({
                            token: lastDeclaration,
                            nextToken: thisDeclaration,
                            message: 'Variable assignments should be followed by new line'
                        });
                    }
                    lastDeclaration = thisDeclaration;
                }
            }
        });
    }
    check: function(file, errors) {
        var lastDeclaration;
Function (anonymous_918)
✓ Was called        file.iterateNodesByType('VariableDeclaration', function(node) {···
            if (node.parentNode.type === 'ForStatement' ||
                node.parentNode.type === 'ForInStatement' ||
                node.parentNode.type === 'ForOfStatement') {
                return;
            }

            for (var i = 0; i < node.declarations.length; i++) {
                var thisDeclaration = node.declarations[i];
                if (thisDeclaration.parentNode.kind === 'var' ||
                    thisDeclaration.parentNode.kind === 'let' ||
                    thisDeclaration.parentNode.kind === 'const') {
                    if (lastDeclaration && lastDeclaration.init) {
                        errors.assert.differentLine({
                            token: lastDeclaration,
                            nextToken: thisDeclaration,
                            message: 'Variable assignments should be followed by new line'
                        });
                    }
                    lastDeclaration = thisDeclaration;
                }
            }
        });
        file.iterateNodesByType('VariableDeclaration', function(node) {
Branch IfStatement
✓ Positive was executed (if)                node.parentNode.type === 'ForOfStatement') {···
                return;
            }
✓ Negative was executed (else)            }···

            for (var i = 0; i < node.declarations.length; i++) {
Branch LogicalExpression
✓ Was returned                node.parentNode.type === 'ForOfStatement') {
✓ Was returned            if (node.parentNode.type === 'ForStatement' ||···
                node.parentNode.type === 'ForInStatement' ||
Branch LogicalExpression
✓ Was returned                node.parentNode.type === 'ForInStatement' ||
✓ Was returned            if (node.parentNode.type === 'ForStatement' ||
            if (node.parentNode.type === 'ForStatement' ||
                node.parentNode.type === 'ForInStatement' ||
                node.parentNode.type === 'ForOfStatement') {
                return;
            }
            for (var i = 0; i < node.declarations.length; i++) {
                var thisDeclaration = node.declarations[i];
Branch IfStatement
✓ Positive was executed (if)                    thisDeclaration.parentNode.kind === 'const') {···
                    if (lastDeclaration && lastDeclaration.init) {
                        errors.assert.differentLine({
                            token: lastDeclaration,
                            nextToken: thisDeclaration,
                            message: 'Variable assignments should be followed by new line'
                        });
                    }
                    lastDeclaration = thisDeclaration;
                }
✗ Negative was not executed (else)                }···
            }
Branch LogicalExpression
✓ Was returned                    thisDeclaration.parentNode.kind === 'const') {
✓ Was returned                if (thisDeclaration.parentNode.kind === 'var' ||···
                    thisDeclaration.parentNode.kind === 'let' ||
Branch LogicalExpression
✓ Was returned                    thisDeclaration.parentNode.kind === 'let' ||
✓ Was returned                if (thisDeclaration.parentNode.kind === 'var' ||
                if (thisDeclaration.parentNode.kind === 'var' ||
                    thisDeclaration.parentNode.kind === 'let' ||
                    thisDeclaration.parentNode.kind === 'const') {
Branch IfStatement
✓ Positive was executed (if)                    if (lastDeclaration && lastDeclaration.init) {···
                        errors.assert.differentLine({
                            token: lastDeclaration,
                            nextToken: thisDeclaration,
                            message: 'Variable assignments should be followed by new line'
                        });
                    }
✓ Negative was executed (else)                    }···
                    lastDeclaration = thisDeclaration;
Branch LogicalExpression
✓ Was returned                    if (lastDeclaration && lastDeclaration.init) {
✓ Was returned                    if (lastDeclaration && lastDeclaration.init) {
                    if (lastDeclaration && lastDeclaration.init) {
                        errors.assert.differentLine({
                            token: lastDeclaration,
                            nextToken: thisDeclaration,
                            message: 'Variable assignments should be followed by new line'
                        });
                    }
                    lastDeclaration = thisDeclaration;
                }
            }
        });
    }
};

require-padding-newline-after-variable-declaration.js
/**
 * Requires an extra blank newline after var declarations, as long
 * as it is not the last expression in the current block.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "requirePaddingNewLineAfterVariableDeclaration": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var x = {
 *     a: 1
 * };
 *
 * foo({
 *     a: {
 *         b: 1
 *     }
 * });
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = { a: 1 };
 * foo({a:{b:1}});
 * ```
 */
var assert = require('assert');
Function (anonymous_919)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_920)
✓ Was called    configure: function(requirePaddingNewLineAfterVariableDeclaration) {···
        assert(
            requirePaddingNewLineAfterVariableDeclaration === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(requirePaddingNewLineAfterVariableDeclaration) {
        assert(
            requirePaddingNewLineAfterVariableDeclaration === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_921)
✓ Was called    getOptionName: function() {···
        return 'requirePaddingNewLineAfterVariableDeclaration';
    },
    getOptionName: function() {
        return 'requirePaddingNewLineAfterVariableDeclaration';
    },
Function (anonymous_922)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('VariableDeclaration', function(node) {
            if (node.parentNode.type === 'ForStatement' ||
                node.parentNode.type === 'ForInStatement' ||
                node.parentNode.type === 'ForOfStatement') {
                return;
            }

            var endOfDeclaration = file.getLastNodeToken(node);
            var nextToken = file.getNextToken(endOfDeclaration);

            if (nextToken.value in {'var': true, 'let': true, 'const': true}) {
                return;
            }

            if (nextToken.value === '}') {
                return;
            }

            if (nextToken.type === 'EOF') {
                return;
            }

            errors.assert.linesBetween({
                atLeast: 2,
                token: endOfDeclaration,
                nextToken: nextToken
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_923)
✓ Was called        file.iterateNodesByType('VariableDeclaration', function(node) {···
            if (node.parentNode.type === 'ForStatement' ||
                node.parentNode.type === 'ForInStatement' ||
                node.parentNode.type === 'ForOfStatement') {
                return;
            }

            var endOfDeclaration = file.getLastNodeToken(node);
            var nextToken = file.getNextToken(endOfDeclaration);

            if (nextToken.value in {'var': true, 'let': true, 'const': true}) {
                return;
            }

            if (nextToken.value === '}') {
                return;
            }

            if (nextToken.type === 'EOF') {
                return;
            }

            errors.assert.linesBetween({
                atLeast: 2,
                token: endOfDeclaration,
                nextToken: nextToken
            });
        });
        file.iterateNodesByType('VariableDeclaration', function(node) {
Branch IfStatement
✓ Positive was executed (if)                node.parentNode.type === 'ForOfStatement') {···
                return;
            }
✓ Negative was executed (else)            }···

            var endOfDeclaration = file.getLastNodeToken(node);
Branch LogicalExpression
✓ Was returned                node.parentNode.type === 'ForOfStatement') {
✓ Was returned            if (node.parentNode.type === 'ForStatement' ||···
                node.parentNode.type === 'ForInStatement' ||
Branch LogicalExpression
✓ Was returned                node.parentNode.type === 'ForInStatement' ||
✓ Was returned            if (node.parentNode.type === 'ForStatement' ||
            if (node.parentNode.type === 'ForStatement' ||
                node.parentNode.type === 'ForInStatement' ||
                node.parentNode.type === 'ForOfStatement') {
                return;
            }
            var endOfDeclaration = file.getLastNodeToken(node);
            var nextToken = file.getNextToken(endOfDeclaration);
Branch IfStatement
✓ Positive was executed (if)            if (nextToken.value in {'var': true, 'let': true, 'const': true}) {···
                return;
            }
✓ Negative was executed (else)            }···

            if (nextToken.value === '}') {
            if (nextToken.value in {'var': true, 'let': true, 'const': true}) {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (nextToken.value === '}') {···
                return;
            }
✓ Negative was executed (else)            }···

            if (nextToken.type === 'EOF') {
            if (nextToken.value === '}') {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (nextToken.type === 'EOF') {···
                return;
            }
✓ Negative was executed (else)            }···

            errors.assert.linesBetween({
            if (nextToken.type === 'EOF') {
                return;
            }
            errors.assert.linesBetween({
                atLeast: 2,
                token: endOfDeclaration,
                nextToken: nextToken
            });
        });
    }
};

disallow-padding-newlines-after-use-strict.js
/**
 * Disallow a blank line after `'use strict';` statements
 *
 * Values: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowPaddingNewLinesAfterUseStrict": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * 'use strict';
 * // code
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * 'use strict';
 *
 * // code
 * ```
 */
var assert = require('assert');
Function (anonymous_924)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_925)
✓ Was called    configure: function(disallowPaddingNewLinesAfterUseStrict) {···
        assert(
            disallowPaddingNewLinesAfterUseStrict === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(disallowPaddingNewLinesAfterUseStrict) {
        assert(
            disallowPaddingNewLinesAfterUseStrict === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_926)
✓ Was called    getOptionName: function() {···
        return 'disallowPaddingNewLinesAfterUseStrict';
    },
    getOptionName: function() {
        return 'disallowPaddingNewLinesAfterUseStrict';
    },
Function (anonymous_927)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('ExpressionStatement', function(node) {
            var expression = node.expression;

            if (expression.type !== 'Literal' || expression.value !== 'use strict') {
                return;
            }

            var endOfNode = file.getLastNodeToken(node);
            var nextToken = file.getNextToken(endOfNode, {
                includeComments: true
            });

            errors.assert.linesBetween({
                atMost: 1,
                token: endOfNode,
                nextToken: nextToken
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_928)
✓ Was called        file.iterateNodesByType('ExpressionStatement', function(node) {···
            var expression = node.expression;

            if (expression.type !== 'Literal' || expression.value !== 'use strict') {
                return;
            }

            var endOfNode = file.getLastNodeToken(node);
            var nextToken = file.getNextToken(endOfNode, {
                includeComments: true
            });

            errors.assert.linesBetween({
                atMost: 1,
                token: endOfNode,
                nextToken: nextToken
            });
        });
        file.iterateNodesByType('ExpressionStatement', function(node) {
            var expression = node.expression;
Branch IfStatement
✓ Positive was executed (if)            if (expression.type !== 'Literal' || expression.value !== 'use strict') {···
                return;
            }
✓ Negative was executed (else)            }···

            var endOfNode = file.getLastNodeToken(node);
Branch LogicalExpression
✓ Was returned            if (expression.type !== 'Literal' || expression.value !== 'use strict') {
✓ Was returned            if (expression.type !== 'Literal' || expression.value !== 'use strict') {
            if (expression.type !== 'Literal' || expression.value !== 'use strict') {
                return;
            }
            var endOfNode = file.getLastNodeToken(node);
            var nextToken = file.getNextToken(endOfNode, {
                includeComments: true
            });
            errors.assert.linesBetween({
                atMost: 1,
                token: endOfNode,
                nextToken: nextToken
            });
        });
    }
};

require-padding-newlines-after-use-strict.js
/**
 * Requires a blank line after `'use strict';` statements
 *
 * Values: `true`
 *
 * #### Example
 *
 * ```js
 * "requirePaddingNewLinesAfterUseStrict": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * 'use strict';
 *
 * // code
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * 'use strict';
 * // code
 * ```
 */
var assert = require('assert');
Function (anonymous_929)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_930)
✓ Was called    configure: function(requirePaddingNewLinesAfterUseStrict) {···
        assert(
            requirePaddingNewLinesAfterUseStrict === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(requirePaddingNewLinesAfterUseStrict) {
        assert(
            requirePaddingNewLinesAfterUseStrict === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_931)
✓ Was called    getOptionName: function() {···
        return 'requirePaddingNewLinesAfterUseStrict';
    },
    getOptionName: function() {
        return 'requirePaddingNewLinesAfterUseStrict';
    },
Function (anonymous_932)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('ExpressionStatement', function(node) {
            var expression = node.expression;

            if (expression.type !== 'Literal' || expression.value !== 'use strict') {
                return;
            }

            var endOfNode = file.getLastNodeToken(node);
            var nextToken = file.getNextToken(endOfNode, {
                includeComments: true
            });

            errors.assert.linesBetween({
                atLeast: 2,
                token: endOfNode,
                nextToken: nextToken
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_933)
✓ Was called        file.iterateNodesByType('ExpressionStatement', function(node) {···
            var expression = node.expression;

            if (expression.type !== 'Literal' || expression.value !== 'use strict') {
                return;
            }

            var endOfNode = file.getLastNodeToken(node);
            var nextToken = file.getNextToken(endOfNode, {
                includeComments: true
            });

            errors.assert.linesBetween({
                atLeast: 2,
                token: endOfNode,
                nextToken: nextToken
            });
        });
        file.iterateNodesByType('ExpressionStatement', function(node) {
            var expression = node.expression;
Branch IfStatement
✓ Positive was executed (if)            if (expression.type !== 'Literal' || expression.value !== 'use strict') {···
                return;
            }
✓ Negative was executed (else)            }···

            var endOfNode = file.getLastNodeToken(node);
Branch LogicalExpression
✓ Was returned            if (expression.type !== 'Literal' || expression.value !== 'use strict') {
✓ Was returned            if (expression.type !== 'Literal' || expression.value !== 'use strict') {
            if (expression.type !== 'Literal' || expression.value !== 'use strict') {
                return;
            }
            var endOfNode = file.getLastNodeToken(node);
            var nextToken = file.getNextToken(endOfNode, {
                includeComments: true
            });
            errors.assert.linesBetween({
                atLeast: 2,
                token: endOfNode,
                nextToken: nextToken
            });
        });
    }
};

disallow-padding-newlines-before-export.js
/**
 * Disallows newline before module.exports
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowPaddingNewLinesBeforeExport": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var a = 2;
 * module.exports = a;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var a = 2;
 *
 * module.exports = a;
 * ```
 */
var assert = require('assert');
Function (anonymous_934)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_935)
✓ Was called    configure: function(value) {···
        assert(
            value === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(value) {
        assert(
            value === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_936)
✓ Was called    getOptionName: function() {···
        return 'disallowPaddingNewLinesBeforeExport';
    },
    getOptionName: function() {
        return 'disallowPaddingNewLinesBeforeExport';
    },
Function (anonymous_937)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('AssignmentExpression', function(node) {
            var left = node.left;
            if (!(
                left.object &&
                left.object.name === 'module' &&
                left.property &&
                left.property.name === 'exports')) {
                return;
            }

            var firstToken = file.getFirstNodeToken(node);
            var prevToken = file.getPrevToken(firstToken, {includeComments: true});

            errors.assert.linesBetween({
                atMost: 1,
                token: prevToken,
                nextToken: firstToken,
                message: 'Unexpected extra newline before export'
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_938)
✓ Was called        file.iterateNodesByType('AssignmentExpression', function(node) {···
            var left = node.left;
            if (!(
                left.object &&
                left.object.name === 'module' &&
                left.property &&
                left.property.name === 'exports')) {
                return;
            }

            var firstToken = file.getFirstNodeToken(node);
            var prevToken = file.getPrevToken(firstToken, {includeComments: true});

            errors.assert.linesBetween({
                atMost: 1,
                token: prevToken,
                nextToken: firstToken,
                message: 'Unexpected extra newline before export'
            });
        });
        file.iterateNodesByType('AssignmentExpression', function(node) {
            var left = node.left;
Branch IfStatement
✓ Positive was executed (if)                left.property.name === 'exports')) {···
                return;
            }
✓ Negative was executed (else)            }···

            var firstToken = file.getFirstNodeToken(node);
            if (!(
Branch LogicalExpression
✓ Was returned                left.property.name === 'exports')) {
✓ Was returned                left.object &&···
                left.object.name === 'module' &&
                left.property &&
Branch LogicalExpression
✓ Was returned                left.property &&
✓ Was returned                left.object &&···
                left.object.name === 'module' &&
Branch LogicalExpression
✓ Was returned                left.object.name === 'module' &&
✗ Was not returned                left.object &&
                left.object &&
                left.object.name === 'module' &&
                left.property &&
                left.property.name === 'exports')) {
                return;
            }
            var firstToken = file.getFirstNodeToken(node);
            var prevToken = file.getPrevToken(firstToken, {includeComments: true});
            errors.assert.linesBetween({
                atMost: 1,
                token: prevToken,
                nextToken: firstToken,
                message: 'Unexpected extra newline before export'
            });
        });
    }
};

require-padding-newlines-before-export.js
/**
 * Requires newline before module.exports
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "requirePaddingNewLinesBeforeExport": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var a = 2;
 *
 * module.exports = a;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var a = 2;
 * module.exports = a;
 * ```
 */
var assert = require('assert');
Function (anonymous_939)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_940)
✓ Was called    configure: function(value) {···
        assert(
            value === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(value) {
        assert(
            value === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_941)
✓ Was called    getOptionName: function() {···
        return 'requirePaddingNewLinesBeforeExport';
    },
    getOptionName: function() {
        return 'requirePaddingNewLinesBeforeExport';
    },
Function (anonymous_942)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('AssignmentExpression', function(node) {
            var left = node.left;
            if (!(
                left.object &&
                left.object.name === 'module' &&
                left.property &&
                left.property.name === 'exports')) {
                return;
            }

            var firstToken = file.getFirstNodeToken(node);
            var prevToken = file.getPrevToken(firstToken);

            errors.assert.linesBetween({
                atLeast: 2,
                token: prevToken,
                nextToken: firstToken,
                message: 'Missing newline before export'
            });
        });
    }
    check: function(file, errors) {
Function (anonymous_943)
✓ Was called        file.iterateNodesByType('AssignmentExpression', function(node) {···
            var left = node.left;
            if (!(
                left.object &&
                left.object.name === 'module' &&
                left.property &&
                left.property.name === 'exports')) {
                return;
            }

            var firstToken = file.getFirstNodeToken(node);
            var prevToken = file.getPrevToken(firstToken);

            errors.assert.linesBetween({
                atLeast: 2,
                token: prevToken,
                nextToken: firstToken,
                message: 'Missing newline before export'
            });
        });
        file.iterateNodesByType('AssignmentExpression', function(node) {
            var left = node.left;
Branch IfStatement
✓ Positive was executed (if)                left.property.name === 'exports')) {···
                return;
            }
✓ Negative was executed (else)            }···

            var firstToken = file.getFirstNodeToken(node);
            if (!(
Branch LogicalExpression
✓ Was returned                left.property.name === 'exports')) {
✓ Was returned                left.object &&···
                left.object.name === 'module' &&
                left.property &&
Branch LogicalExpression
✓ Was returned                left.property &&
✓ Was returned                left.object &&···
                left.object.name === 'module' &&
Branch LogicalExpression
✓ Was returned                left.object.name === 'module' &&
✗ Was not returned                left.object &&
                left.object &&
                left.object.name === 'module' &&
                left.property &&
                left.property.name === 'exports')) {
                return;
            }
            var firstToken = file.getFirstNodeToken(node);
            var prevToken = file.getPrevToken(firstToken);
            errors.assert.linesBetween({
                atLeast: 2,
                token: prevToken,
                nextToken: firstToken,
                message: 'Missing newline before export'
            });
        });
    }
};

require-semicolons.js
/**
 * Requires semicolon after:
 *
 * * var declaration
 * * expression statement
 * * return
 * * throw
 * * break
 * * continue
 * * do-while
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "requireSemicolons": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var a = 1;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var a = 1
 * ```
*/
var assert = require('assert');
Function (anonymous_944)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_945)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_946)
✓ Was called    getOptionName: function() {···
        return 'requireSemicolons';
    },
    getOptionName: function() {
        return 'requireSemicolons';
    },
Function (anonymous_947)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType([
            'VariableDeclaration',
            'ExpressionStatement',
            'DoWhileStatement',
            'ReturnStatement',
            'ThrowStatement',
            'BreakStatement',
            'ContinueStatement',
            'DebuggerStatement'
        ], function(node) {
            // ignore variable declaration inside for and for-in
            if (node.type === 'VariableDeclaration') {
                if ((node.parentNode.type === 'ForInStatement' && node.parentNode.left === node) ||
                    (node.parentNode.type === 'ForOfStatement' && node.parentNode.left === node) ||
                    (node.parentNode.type === 'ForStatement' && node.parentNode.init === node)) {
                    return;
                }
            }

            // get last token inside node
            var lastToken = file.getLastNodeToken(node);
            var checkToken = lastToken;

            // if last token is not a semicolon punctuator, try to get next token in file
            if (checkToken && (checkToken.type !== 'Punctuator' || checkToken.value !== ';')) {
                checkToken = file.getNextToken(checkToken);
            }

            // check token is semicolon
            if (!checkToken || checkToken.type !== 'Punctuator' || checkToken.value !== ';') {
                errors.add(
                    'Missing semicolon after statement',
                    (lastToken || node).loc.end
                );
            }
        });
    }
    check: function(file, errors) {
        file.iterateNodesByType([
            'VariableDeclaration',
            'ExpressionStatement',
            'DoWhileStatement',
            'ReturnStatement',
            'ThrowStatement',
            'BreakStatement',
            'ContinueStatement',
            'DebuggerStatement'
Function (anonymous_948)
✓ Was called        ], function(node) {···
            // ignore variable declaration inside for and for-in
            if (node.type === 'VariableDeclaration') {
                if ((node.parentNode.type === 'ForInStatement' && node.parentNode.left === node) ||
                    (node.parentNode.type === 'ForOfStatement' && node.parentNode.left === node) ||
                    (node.parentNode.type === 'ForStatement' && node.parentNode.init === node)) {
                    return;
                }
            }

            // get last token inside node
            var lastToken = file.getLastNodeToken(node);
            var checkToken = lastToken;

            // if last token is not a semicolon punctuator, try to get next token in file
            if (checkToken && (checkToken.type !== 'Punctuator' || checkToken.value !== ';')) {
                checkToken = file.getNextToken(checkToken);
            }

            // check token is semicolon
            if (!checkToken || checkToken.type !== 'Punctuator' || checkToken.value !== ';') {
                errors.add(
                    'Missing semicolon after statement',
                    (lastToken || node).loc.end
                );
            }
        });
        ], function(node) {
            // ignore variable declaration inside for and for-in
Branch IfStatement
✓ Positive was executed (if)            if (node.type === 'VariableDeclaration') {···
                if ((node.parentNode.type === 'ForInStatement' && node.parentNode.left === node) ||
                    (node.parentNode.type === 'ForOfStatement' && node.parentNode.left === node) ||
                    (node.parentNode.type === 'ForStatement' && node.parentNode.init === node)) {
                    return;
                }
            }
✓ Negative was executed (else)            }···

            // get last token inside node
            if (node.type === 'VariableDeclaration') {
Branch IfStatement
✓ Positive was executed (if)                    (node.parentNode.type === 'ForStatement' && node.parentNode.init === node)) {···
                    return;
                }
✓ Negative was executed (else)                }···
            }
Branch LogicalExpression
✓ Was returned                    (node.parentNode.type === 'ForStatement' && node.parentNode.init === node)) {
✓ Was returned                if ((node.parentNode.type === 'ForInStatement' && node.parentNode.left === node) ||···
                    (node.parentNode.type === 'ForOfStatement' && node.parentNode.left === node) ||
Branch LogicalExpression
✓ Was returned                    (node.parentNode.type === 'ForOfStatement' && node.parentNode.left === node) ||
✓ Was returned                if ((node.parentNode.type === 'ForInStatement' && node.parentNode.left === node) ||
Branch LogicalExpression
✓ Was returned                if ((node.parentNode.type === 'ForInStatement' && node.parentNode.left === node) ||
✓ Was returned                if ((node.parentNode.type === 'ForInStatement' && node.parentNode.left === node) ||
                if ((node.parentNode.type === 'ForInStatement' && node.parentNode.left === node) ||
Branch LogicalExpression
✓ Was returned                    (node.parentNode.type === 'ForOfStatement' && node.parentNode.left === node) ||
✓ Was returned                    (node.parentNode.type === 'ForOfStatement' && node.parentNode.left === node) ||
                    (node.parentNode.type === 'ForOfStatement' && node.parentNode.left === node) ||
Branch LogicalExpression
✓ Was returned                    (node.parentNode.type === 'ForStatement' && node.parentNode.init === node)) {
✓ Was returned                    (node.parentNode.type === 'ForStatement' && node.parentNode.init === node)) {
                    (node.parentNode.type === 'ForStatement' && node.parentNode.init === node)) {
                    return;
                }
            }
            // get last token inside node
            var lastToken = file.getLastNodeToken(node);
            var checkToken = lastToken;
            // if last token is not a semicolon punctuator, try to get next token in file
Branch IfStatement
✓ Positive was executed (if)            if (checkToken && (checkToken.type !== 'Punctuator' || checkToken.value !== ';')) {···
                checkToken = file.getNextToken(checkToken);
            }
✓ Negative was executed (else)            }···

            // check token is semicolon
Branch LogicalExpression
✓ Was returned            if (checkToken && (checkToken.type !== 'Punctuator' || checkToken.value !== ';')) {
✓ Was returned            if (checkToken && (checkToken.type !== 'Punctuator' || checkToken.value !== ';')) {
Branch LogicalExpression
✓ Was returned            if (checkToken && (checkToken.type !== 'Punctuator' || checkToken.value !== ';')) {
✓ Was returned            if (checkToken && (checkToken.type !== 'Punctuator' || checkToken.value !== ';')) {
            if (checkToken && (checkToken.type !== 'Punctuator' || checkToken.value !== ';')) {
                checkToken = file.getNextToken(checkToken);
            }
            // check token is semicolon
Branch IfStatement
✓ Positive was executed (if)            if (!checkToken || checkToken.type !== 'Punctuator' || checkToken.value !== ';') {···
                errors.add(
                    'Missing semicolon after statement',
                    (lastToken || node).loc.end
                );
            }
✓ Negative was executed (else)            }···
        });
Branch LogicalExpression
✓ Was returned            if (!checkToken || checkToken.type !== 'Punctuator' || checkToken.value !== ';') {
✓ Was returned            if (!checkToken || checkToken.type !== 'Punctuator' || checkToken.value !== ';') {
Branch LogicalExpression
✓ Was returned            if (!checkToken || checkToken.type !== 'Punctuator' || checkToken.value !== ';') {
✓ Was returned            if (!checkToken || checkToken.type !== 'Punctuator' || checkToken.value !== ';') {
            if (!checkToken || checkToken.type !== 'Punctuator' || checkToken.value !== ';') {
                errors.add(
                    'Missing semicolon after statement',
Branch LogicalExpression
✓ Was returned                    (lastToken || node).loc.end
✓ Was returned                    (lastToken || node).loc.end
                    (lastToken || node).loc.end
                );
            }
        });
    }
};

disallow-semicolons.js
/**
 * Disallows lines from ending in a semicolon.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowSemicolons": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var a = 1
 * ;[b].forEach(c)
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var a = 1;
 * [b].forEach(c);
 * ```
 */
var assert = require('assert');
Function (anonymous_949)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_950)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_951)
✓ Was called    getOptionName: function() {···
        return 'disallowSemicolons';
    },
    getOptionName: function() {
        return 'disallowSemicolons';
    },
Function (anonymous_952)
✓ Was called    check: function(file, errors) {···
        file.iterateTokensByTypeAndValue('Punctuator', ';', function(token) {
            var nextToken = file.getNextToken(token);
            // do not use assertions here as this is not yet autofixable
            if (nextToken.type === 'EOF' || nextToken.loc.end.line > token.loc.end.line) {
                errors.add('semicolons are disallowed at the end of a line.', token.loc.end);
            }
        });
    }
    check: function(file, errors) {
Function (anonymous_953)
✓ Was called        file.iterateTokensByTypeAndValue('Punctuator', ';', function(token) {···
            var nextToken = file.getNextToken(token);
            // do not use assertions here as this is not yet autofixable
            if (nextToken.type === 'EOF' || nextToken.loc.end.line > token.loc.end.line) {
                errors.add('semicolons are disallowed at the end of a line.', token.loc.end);
            }
        });
        file.iterateTokensByTypeAndValue('Punctuator', ';', function(token) {
            var nextToken = file.getNextToken(token);
            // do not use assertions here as this is not yet autofixable
Branch IfStatement
✓ Positive was executed (if)            if (nextToken.type === 'EOF' || nextToken.loc.end.line > token.loc.end.line) {···
                errors.add('semicolons are disallowed at the end of a line.', token.loc.end);
            }
✓ Negative was executed (else)            }···
        });
Branch LogicalExpression
✓ Was returned            if (nextToken.type === 'EOF' || nextToken.loc.end.line > token.loc.end.line) {
✓ Was returned            if (nextToken.type === 'EOF' || nextToken.loc.end.line > token.loc.end.line) {
            if (nextToken.type === 'EOF' || nextToken.loc.end.line > token.loc.end.line) {
                errors.add('semicolons are disallowed at the end of a line.', token.loc.end);
            }
        });
    }
};

require-spaces-in-for-statement.js
/**
 * Requires spaces inbetween for statement.
 *
 * Type: `Boolean`
 *
 * Value: `true` to requires spaces inbetween for statement.
 *
 * #### Example
 *
 * ```js
 * "requireSpacesInForStatement": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * for(var i = 0; i<l; i++) {
 *     x++;
 * }
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * for(var i = 0;i<l;i++) {
 *     x++;
 * }
 * ```
 *
 * ```js
 * for(var i = 0; i<l;i++) {
 *     x++;
 * }
 * ```
 *
 * ```js
 * for(var i = 0;i<l; i++) {
 *     x++;
 * }
 * ```
 */
var assert = require('assert');
Function (anonymous_954)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_955)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_956)
✓ Was called    getOptionName: function() {···
        return 'requireSpacesInForStatement';
    },
    getOptionName: function() {
        return 'requireSpacesInForStatement';
    },
Function (anonymous_957)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('ForStatement', function(node) {
            if (node.test) {
                var testToken = file.getFirstNodeToken(node.test);
                errors.assert.spacesBetween({
                    token: file.getPrevToken(testToken),
                    nextToken: testToken,
                    exactly: 1,
                    message: 'One space required after semicolon'
                });
            }
            if (node.update) {
                var updateToken = file.getFirstNodeToken(node.update);
                errors.assert.spacesBetween({
                    token: file.getPrevToken(updateToken),
                    nextToken: updateToken,
                    exactly: 1,
                    message: 'One space required after semicolon'
                });
            }
        });
    }
    check: function(file, errors) {
Function (anonymous_958)
✓ Was called        file.iterateNodesByType('ForStatement', function(node) {···
            if (node.test) {
                var testToken = file.getFirstNodeToken(node.test);
                errors.assert.spacesBetween({
                    token: file.getPrevToken(testToken),
                    nextToken: testToken,
                    exactly: 1,
                    message: 'One space required after semicolon'
                });
            }
            if (node.update) {
                var updateToken = file.getFirstNodeToken(node.update);
                errors.assert.spacesBetween({
                    token: file.getPrevToken(updateToken),
                    nextToken: updateToken,
                    exactly: 1,
                    message: 'One space required after semicolon'
                });
            }
        });
        file.iterateNodesByType('ForStatement', function(node) {
Branch IfStatement
✓ Positive was executed (if)            if (node.test) {···
                var testToken = file.getFirstNodeToken(node.test);
                errors.assert.spacesBetween({
                    token: file.getPrevToken(testToken),
                    nextToken: testToken,
                    exactly: 1,
                    message: 'One space required after semicolon'
                });
            }
✓ Negative was executed (else)            }···
            if (node.update) {
            if (node.test) {
                var testToken = file.getFirstNodeToken(node.test);
                errors.assert.spacesBetween({
                    token: file.getPrevToken(testToken),
                    nextToken: testToken,
                    exactly: 1,
                    message: 'One space required after semicolon'
                });
            }
Branch IfStatement
✓ Positive was executed (if)            if (node.update) {···
                var updateToken = file.getFirstNodeToken(node.update);
                errors.assert.spacesBetween({
                    token: file.getPrevToken(updateToken),
                    nextToken: updateToken,
                    exactly: 1,
                    message: 'One space required after semicolon'
                });
            }
✓ Negative was executed (else)            }···
        });
            if (node.update) {
                var updateToken = file.getFirstNodeToken(node.update);
                errors.assert.spacesBetween({
                    token: file.getPrevToken(updateToken),
                    nextToken: updateToken,
                    exactly: 1,
                    message: 'One space required after semicolon'
                });
            }
        });
    }
};

disallow-spaces-in-for-statement.js
/**
 * Disallow spaces in between for statement.
 *
 * Type: `Boolean`
 *
 * Value: `true` to disallow spaces in between for statement.
 *
 * #### Example
 *
 * ```js
 * "disallowSpacesInForStatement": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * for(var i=0;i<l;i++) {
 *     x++;
 * }
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * for(var i = 0; i<l; i++) {
 *     x++;
 * }
 * ```
 *
 * ```js
 * for(var i = 0; i<l;i++) {
 *     x++;
 * }
 * ```
 *
 * ```js
 * for(var i = 0;i<l; i++) {
 *     x++;
 * }
 * ```
 */
var assert = require('assert');
Function (anonymous_959)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_960)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_961)
✓ Was called    getOptionName: function() {···
        return 'disallowSpacesInForStatement';
    },
    getOptionName: function() {
        return 'disallowSpacesInForStatement';
    },
Function (anonymous_962)
✓ Was called    check: function(file, errors) {···
        file.iterateNodesByType('ForStatement', function(node) {
            if (node.test) {
                var testToken = file.getFirstNodeToken(node.test);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(testToken),
                    nextToken: testToken,
                    message: 'Space found after semicolon'
                });
            }
            if (node.update) {
                var updateToken = file.getFirstNodeToken(node.update);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(updateToken),
                    nextToken: updateToken,
                    message: 'Space found after semicolon'
                });
            }
        });
    }
    check: function(file, errors) {
Function (anonymous_963)
✓ Was called        file.iterateNodesByType('ForStatement', function(node) {···
            if (node.test) {
                var testToken = file.getFirstNodeToken(node.test);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(testToken),
                    nextToken: testToken,
                    message: 'Space found after semicolon'
                });
            }
            if (node.update) {
                var updateToken = file.getFirstNodeToken(node.update);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(updateToken),
                    nextToken: updateToken,
                    message: 'Space found after semicolon'
                });
            }
        });
        file.iterateNodesByType('ForStatement', function(node) {
Branch IfStatement
✓ Positive was executed (if)            if (node.test) {···
                var testToken = file.getFirstNodeToken(node.test);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(testToken),
                    nextToken: testToken,
                    message: 'Space found after semicolon'
                });
            }
✓ Negative was executed (else)            }···
            if (node.update) {
            if (node.test) {
                var testToken = file.getFirstNodeToken(node.test);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(testToken),
                    nextToken: testToken,
                    message: 'Space found after semicolon'
                });
            }
Branch IfStatement
✓ Positive was executed (if)            if (node.update) {···
                var updateToken = file.getFirstNodeToken(node.update);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(updateToken),
                    nextToken: updateToken,
                    message: 'Space found after semicolon'
                });
            }
✓ Negative was executed (else)            }···
        });
            if (node.update) {
                var updateToken = file.getFirstNodeToken(node.update);
                errors.assert.noWhitespaceBetween({
                    token: file.getPrevToken(updateToken),
                    nextToken: updateToken,
                    message: 'Space found after semicolon'
                });
            }
        });
    }
};

disallow-keywords-in-comments.js
/**
 * Disallows keywords in your comments, such as TODO or FIXME
 *
 * Types: `Boolean`, `String` or `Array`
 *
 * Values:
 * - `true`
 * - `'\b(word1|word2)\b'`
 * - `['word1', 'word2']`
 *
 * #### Examples
 *
 * ```js
 * "disallowKeywordsInComments": true
 * "disallowKeywordsInComments": "\\b(word1|word2)\\b"
 * "disallowKeywordsInComments": ["word1", "word2"]
 * ```
 *
 * #### Invalid:
 * ```
 * // ToDo
 * //TODO
 * /** fixme *\/
 * /**
 *  * FIXME
 *  *\/
 * ```
 */
var assert = require('assert');
Function getCommentErrors
✓ Was calledfunction getCommentErrors(comment, keywordRegEx) {···
    var splitComment = comment.value.split('\n');
    var errors = [];

    splitComment.forEach(function(commentNode, index) {
        var lineIndex = index;
        var matches = commentNode.match(keywordRegEx);
        var lastIndex = -1;

        if (!matches) { return; }

        errors = errors.concat(matches.map(function(match) {
            lastIndex++;
            lastIndex = commentNode.indexOf(match, lastIndex);

            // line + lineIndex because comment block was split at new lines
            //   will place carat at correct place within multiline comment
            // foundAtIndex += 2 because comment opening is stripped
            //   +2 finds accurate carat position on opening line comment
            return {
                line: comment.loc.start.line + lineIndex,
                column: lastIndex + (lineIndex > 0 ? 0 : 2)
            };
        }));
    });

    return errors;
}
function getCommentErrors(comment, keywordRegEx) {
    var splitComment = comment.value.split('\n');
    var errors = [];
Function (anonymous_965)
✓ Was called    splitComment.forEach(function(commentNode, index) {···
        var lineIndex = index;
        var matches = commentNode.match(keywordRegEx);
        var lastIndex = -1;

        if (!matches) { return; }

        errors = errors.concat(matches.map(function(match) {
            lastIndex++;
            lastIndex = commentNode.indexOf(match, lastIndex);

            // line + lineIndex because comment block was split at new lines
            //   will place carat at correct place within multiline comment
            // foundAtIndex += 2 because comment opening is stripped
            //   +2 finds accurate carat position on opening line comment
            return {
                line: comment.loc.start.line + lineIndex,
                column: lastIndex + (lineIndex > 0 ? 0 : 2)
            };
        }));
    });
    splitComment.forEach(function(commentNode, index) {
        var lineIndex = index;
        var matches = commentNode.match(keywordRegEx);
        var lastIndex = -1;
Branch IfStatement
✓ Positive was executed (if)        if (!matches) { return; }
✓ Negative was executed (else)        if (!matches) { return; }···

        errors = errors.concat(matches.map(function(match) {
        if (!matches) { return; }
Function (anonymous_966)
✓ Was called        errors = errors.concat(matches.map(function(match) {···
            lastIndex++;
            lastIndex = commentNode.indexOf(match, lastIndex);

            // line + lineIndex because comment block was split at new lines
            //   will place carat at correct place within multiline comment
            // foundAtIndex += 2 because comment opening is stripped
            //   +2 finds accurate carat position on opening line comment
            return {
                line: comment.loc.start.line + lineIndex,
                column: lastIndex + (lineIndex > 0 ? 0 : 2)
            };
        }));
        errors = errors.concat(matches.map(function(match) {
            lastIndex++;
            lastIndex = commentNode.indexOf(match, lastIndex);
            // line + lineIndex because comment block was split at new lines
            //   will place carat at correct place within multiline comment
            // foundAtIndex += 2 because comment opening is stripped
            //   +2 finds accurate carat position on opening line comment
            return {
                line: comment.loc.start.line + lineIndex,
Branch ConditionalExpression
✓ Positive was returned (? ...)                column: lastIndex + (lineIndex > 0 ? 0 : 2)
✓ Negative was returned (: ...)                column: lastIndex + (lineIndex > 0 ? 0 : 2)
                column: lastIndex + (lineIndex > 0 ? 0 : 2)
            };
        }));
    });
    return errors;
}
Function (anonymous_967)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_968)
✓ Was called    configure: function(keywords) {···
        this._message = 'Comments cannot contain the following keywords: ';
        this._keywords = ['todo', 'fixme'];

        switch (true) {
            case Array.isArray(keywords):
                // use the array of strings provided to build RegExp pattern
                this._keywords = keywords;
                /* falls through */
            case keywords:
                // use default keywords
                this._message += this._keywords.join(', ');
                this._keywordRegEx = new RegExp('\\b(' + this._keywords.join('|') + ')\\b', 'gi');
                break;
            case typeof keywords === 'string':
                // use string passed in as the RegExp pattern
                this._message = 'Comments cannot contain keywords based on the expression you provided';
                this._keywordRegEx = new RegExp(keywords, 'gi');
                break;
            default:
                assert(false, this.getOptionName() + ' option requires a true value, a string or an array');
        }
    },
    configure: function(keywords) {
        this._message = 'Comments cannot contain the following keywords: ';
        this._keywords = ['todo', 'fixme'];
Branch SwitchStatement
✓ Was evaluated            case Array.isArray(keywords):···
                // use the array of strings provided to build RegExp pattern
                this._keywords = keywords;
✓ Was evaluated            case keywords:···
                // use default keywords
                this._message += this._keywords.join(', ');
                this._keywordRegEx = new RegExp('\\b(' + this._keywords.join('|') + ')\\b', 'gi');
                break;
✓ Was evaluated            case typeof keywords === 'string':···
                // use string passed in as the RegExp pattern
                this._message = 'Comments cannot contain keywords based on the expression you provided';
                this._keywordRegEx = new RegExp(keywords, 'gi');
                break;
✓ Was evaluated            default:···
                assert(false, this.getOptionName() + ' option requires a true value, a string or an array');
        switch (true) {
            case Array.isArray(keywords):
                // use the array of strings provided to build RegExp pattern
                this._keywords = keywords;
                /* falls through */
            case keywords:
                // use default keywords
                this._message += this._keywords.join(', ');
                this._keywordRegEx = new RegExp('\\b(' + this._keywords.join('|') + ')\\b', 'gi');
                break;
            case typeof keywords === 'string':
                // use string passed in as the RegExp pattern
                this._message = 'Comments cannot contain keywords based on the expression you provided';
                this._keywordRegEx = new RegExp(keywords, 'gi');
                break;
            default:
                assert(false, this.getOptionName() + ' option requires a true value, a string or an array');
        }
    },
Function (anonymous_969)
✓ Was called    getOptionName: function() {···
        return 'disallowKeywordsInComments';
    },
    getOptionName: function() {
        return 'disallowKeywordsInComments';
    },
Function (anonymous_970)
✓ Was called    check: function(file, errors) {···
        file.iterateTokensByType(['Line', 'Block'], function(comment) {
            getCommentErrors(comment, this._keywordRegEx).forEach(function(errorObj) {
                errors.add(this._message, errorObj);
            }.bind(this));
        }.bind(this));
    }
    check: function(file, errors) {
Function (anonymous_971)
✓ Was called        file.iterateTokensByType(['Line', 'Block'], function(comment) {···
            getCommentErrors(comment, this._keywordRegEx).forEach(function(errorObj) {
                errors.add(this._message, errorObj);
            }.bind(this));
        }.bind(this));
        file.iterateTokensByType(['Line', 'Block'], function(comment) {
Function (anonymous_972)
✓ Was called            getCommentErrors(comment, this._keywordRegEx).forEach(function(errorObj) {···
                errors.add(this._message, errorObj);
            }.bind(this));
            getCommentErrors(comment, this._keywordRegEx).forEach(function(errorObj) {
                errors.add(this._message, errorObj);
            }.bind(this));
        }.bind(this));
    }
};

disallow-identifier-names.js
/**
 * Disallows a specified set of identifier names.
 *
 * Type: `Array`
 *
 * Values: Array of strings, which should be disallowed as identifier names
 *
 * #### Example
 *
 * ```js
 * "disallowIdentifierNames": ['temp', 'foo']
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var good = 1;
 * object['fine'] = 2;
 * object.fine = 3;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var temp = 1;
 * object['foo'] = 2;
 * object.foo = 3;
 * ```
 */
var assert = require('assert');
Function (anonymous_973)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_974)
✓ Was called    configure: function(identifiers) {···
        assert(
            Array.isArray(identifiers),
            'disallowIdentifierNames option requires an array'
        );

        this._identifierIndex = {};
        for (var i = 0, l = identifiers.length; i < l; i++) {
            this._identifierIndex[identifiers[i]] = true;
        }
    },
    configure: function(identifiers) {
        assert(
            Array.isArray(identifiers),
            'disallowIdentifierNames option requires an array'
        );
        this._identifierIndex = {};
        for (var i = 0, l = identifiers.length; i < l; i++) {
            this._identifierIndex[identifiers[i]] = true;
        }
    },
Function (anonymous_975)
✓ Was called    getOptionName: function() {···
        return 'disallowIdentifierNames';
    },
    getOptionName: function() {
        return 'disallowIdentifierNames';
    },
Function (anonymous_976)
✓ Was called    check: function(file, errors) {···
        var disallowedIdentifiers = this._identifierIndex;

        file.iterateNodesByType('Identifier', function(node) {
            if (Object.prototype.hasOwnProperty.call(disallowedIdentifiers, node.name)) {
                errors.add('Illegal Identifier name: ' + node.name, node.loc.start);
            }
        });

        file.iterateNodesByType('MemberExpression', function(node) {
            if (node.property.type === 'Literal') {
                if (Object.prototype.hasOwnProperty.call(disallowedIdentifiers, node.property.value)) {
                    errors.add('Illegal Identifier name: ' + node.property.value, node.property.loc.start);
                }
            }
        });

    }
    check: function(file, errors) {
        var disallowedIdentifiers = this._identifierIndex;
Function (anonymous_977)
✓ Was called        file.iterateNodesByType('Identifier', function(node) {···
            if (Object.prototype.hasOwnProperty.call(disallowedIdentifiers, node.name)) {
                errors.add('Illegal Identifier name: ' + node.name, node.loc.start);
            }
        });
        file.iterateNodesByType('Identifier', function(node) {
Branch IfStatement
✓ Positive was executed (if)            if (Object.prototype.hasOwnProperty.call(disallowedIdentifiers, node.name)) {···
                errors.add('Illegal Identifier name: ' + node.name, node.loc.start);
            }
✓ Negative was executed (else)            }···
        });
            if (Object.prototype.hasOwnProperty.call(disallowedIdentifiers, node.name)) {
                errors.add('Illegal Identifier name: ' + node.name, node.loc.start);
            }
        });
Function (anonymous_978)
✓ Was called        file.iterateNodesByType('MemberExpression', function(node) {···
            if (node.property.type === 'Literal') {
                if (Object.prototype.hasOwnProperty.call(disallowedIdentifiers, node.property.value)) {
                    errors.add('Illegal Identifier name: ' + node.property.value, node.property.loc.start);
                }
            }
        });
        file.iterateNodesByType('MemberExpression', function(node) {
Branch IfStatement
✓ Positive was executed (if)            if (node.property.type === 'Literal') {···
                if (Object.prototype.hasOwnProperty.call(disallowedIdentifiers, node.property.value)) {
                    errors.add('Illegal Identifier name: ' + node.property.value, node.property.loc.start);
                }
            }
✓ Negative was executed (else)            }···
        });
            if (node.property.type === 'Literal') {
Branch IfStatement
✓ Positive was executed (if)                if (Object.prototype.hasOwnProperty.call(disallowedIdentifiers, node.property.value)) {···
                    errors.add('Illegal Identifier name: ' + node.property.value, node.property.loc.start);
                }
✓ Negative was executed (else)                }···
            }
                if (Object.prototype.hasOwnProperty.call(disallowedIdentifiers, node.property.value)) {
                    errors.add('Illegal Identifier name: ' + node.property.value, node.property.loc.start);
                }
            }
        });
    }
};

maximum-number-of-lines.js
/**
 * Requires the file to be at most the number of lines specified
 *
 * Type: `Integer`
 *
 * Values:
*  - `Integer`: file should be at most the number of lines specified
 *
 * #### Example
 *
 * ```js
 * "maximumNumberOfLines": 100
 * ```
 */
var assert = require('assert');
Function (anonymous_979)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_980)
✓ Was called    configure: function(options) {···
        assert(
            typeof options === 'number',
            this.getOptionName() + ' option requires number value or should be removed'
        );
        this._maximumNumberOfLines = options;
    },
    configure: function(options) {
        assert(
            typeof options === 'number',
            this.getOptionName() + ' option requires number value or should be removed'
        );
        this._maximumNumberOfLines = options;
    },
Function (anonymous_981)
✓ Was called    getOptionName: function() {···
        return 'maximumNumberOfLines';
    },
    getOptionName: function() {
        return 'maximumNumberOfLines';
    },
Function (anonymous_982)
✓ Was called    check: function(file, errors) {···
        var firstToken = file.getFirstToken();
        var lastToken = file.getLastToken();

        errors.assert.linesBetween({
            token: firstToken,
            nextToken: lastToken,
            atMost: this._maximumNumberOfLines - 1,
            message: 'File must be at most ' + this._maximumNumberOfLines + ' lines long'
        });
    }
    check: function(file, errors) {
        var firstToken = file.getFirstToken();
        var lastToken = file.getLastToken();
        errors.assert.linesBetween({
            token: firstToken,
            nextToken: lastToken,
            atMost: this._maximumNumberOfLines - 1,
            message: 'File must be at most ' + this._maximumNumberOfLines + ' lines long'
        });
    }
};

validate-newline-after-array-elements.js
/**
 * Requires each element in array on a single line when array length is more than passed maximum
 * number or array fills more than one line.
 * Set `ignoreBrackets` to `true` to allow elements on the same line with brackets.
 *
 * Type: `Boolean` or `Number` (maximum) or `Object` (`{maximum: Number, ignoreBrackets: Boolean}`)
 *
 * Values: `true`
 *
 * Default: `{maximum: Infinity, ignoreBrackets: false}`
 *
 * #### Example
 *
 * ```js
 * "validateNewlineAfterArrayElements": {
 *   "maximum": 3
 * }
 * ```
 *
 * ##### Valid for `true`
 *
 * ```js
 * var x = [{a: 1}, [2], '3', 4, 5, 6];
 * var x = [
 *   {a: 1},
 *   [2],
 *   '3',
 *   4
 * ];
 * ```
 *
 * ##### Invalid for `true`
 *
 * ```js
 * var x = [1,
 *   2];
 * ```
 *
 * ##### Valid for `3`
 *
 * ```js
 * var x = [{a: 1}, [2], '3'];
 * var x = [
 *   1,
 *   2,
 *   3,
 *   4
 * ];
 * ```
 *
 * ##### Invalid for `3`
 *
 * ```js
 * var x = [1, 2, 3, 4];
 * var x = [1,
 *   2,
 *   3];
 * var x = [
 *     1, 2
 * ];
 * ```
 *
 * ##### Valid for `{maximum: 2, ignoreBrackets: true}`
 *
 * ```js
 * var x = [{a: 1}, [2]];
 * var x = [1,
 *   2,
 *   3];
 * ```
 *
 * ##### Invalid for `{maximum: 2, ignoreBrackets: true}`
 *
 * ```js
 * var x = [1, 2, 3];
 * var x = [1, 2,
 *   3];
 * var x = [1,
 *   2, 3];
 * ```
 */
var assert = require('assert');
Function (anonymous_983)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_984)
✓ Was called    configure: function(opts) {···
        assert(
            opts === true ||
            typeof opts === 'number' && opts >= 1 ||
            typeof opts === 'object',
            this.getOptionName() + ' option requires maximal number of items ' +
                'or true value either should be removed'
        );
        if (typeof opts === 'object') {
            this._options = opts;

            if ('maximum' in opts) {
                assert(typeof opts.maximum === 'number' && opts.maximum >= 1,
                    'maximum property requires a positive number or should be removed');
            } else {
                opts.maximum = Infinity;
            }

            if ('ignoreBrackets' in opts) {
                assert(opts.ignoreBrackets === true,
                    'ignoreBrackets property requires true value or should be removed');
            } else {
                opts.ignoreBrackets = false;
            }

        } else {
            this._options = {
                maximum: opts === true ? Infinity : opts,
                ignoreBrackets: false
            };
        }
    },
    configure: function(opts) {
        assert(
Branch LogicalExpression
✓ Was returned            typeof opts === 'object',
✓ Was returned            opts === true ||···
            typeof opts === 'number' && opts >= 1 ||
Branch LogicalExpression
✓ Was returned            typeof opts === 'number' && opts >= 1 ||
✓ Was returned            opts === true ||
            opts === true ||
Branch LogicalExpression
✓ Was returned            typeof opts === 'number' && opts >= 1 ||
✓ Was returned            typeof opts === 'number' && opts >= 1 ||
            typeof opts === 'number' && opts >= 1 ||
            typeof opts === 'object',
            this.getOptionName() + ' option requires maximal number of items ' +
                'or true value either should be removed'
        );
Branch IfStatement
✓ Positive was executed (if)        if (typeof opts === 'object') {···
            this._options = opts;

            if ('maximum' in opts) {
                assert(typeof opts.maximum === 'number' && opts.maximum >= 1,
                    'maximum property requires a positive number or should be removed');
            } else {
                opts.maximum = Infinity;
            }

            if ('ignoreBrackets' in opts) {
                assert(opts.ignoreBrackets === true,
                    'ignoreBrackets property requires true value or should be removed');
            } else {
                opts.ignoreBrackets = false;
            }

        } else {
✓ Negative was executed (else)        } else {···
            this._options = {
                maximum: opts === true ? Infinity : opts,
                ignoreBrackets: false
            };
        }
        if (typeof opts === 'object') {
            this._options = opts;
Branch IfStatement
✓ Positive was executed (if)            if ('maximum' in opts) {···
                assert(typeof opts.maximum === 'number' && opts.maximum >= 1,
                    'maximum property requires a positive number or should be removed');
            } else {
✓ Negative was executed (else)            } else {···
                opts.maximum = Infinity;
            }
            if ('maximum' in opts) {
Branch LogicalExpression
✓ Was returned                assert(typeof opts.maximum === 'number' && opts.maximum >= 1,
✓ Was returned                assert(typeof opts.maximum === 'number' && opts.maximum >= 1,
                assert(typeof opts.maximum === 'number' && opts.maximum >= 1,
                    'maximum property requires a positive number or should be removed');
            } else {
                opts.maximum = Infinity;
            }
Branch IfStatement
✓ Positive was executed (if)            if ('ignoreBrackets' in opts) {···
                assert(opts.ignoreBrackets === true,
                    'ignoreBrackets property requires true value or should be removed');
            } else {
✓ Negative was executed (else)            } else {···
                opts.ignoreBrackets = false;
            }
            if ('ignoreBrackets' in opts) {
                assert(opts.ignoreBrackets === true,
                    'ignoreBrackets property requires true value or should be removed');
            } else {
                opts.ignoreBrackets = false;
            }
        } else {
            this._options = {
Branch ConditionalExpression
✓ Positive was returned (? ...)                maximum: opts === true ? Infinity : opts,
✓ Negative was returned (: ...)                maximum: opts === true ? Infinity : opts,
                maximum: opts === true ? Infinity : opts,
                ignoreBrackets: false
            };
        }
    },
Function (anonymous_985)
✓ Was called    getOptionName: function() {···
        return 'validateNewlineAfterArrayElements';
    },
    getOptionName: function() {
        return 'validateNewlineAfterArrayElements';
    },
Function (anonymous_986)
✓ Was called    check: function(file, errors) {···
        var maximum = this._options.maximum;
        var ignoreBrackets = this._options.ignoreBrackets;

        file.iterateNodesByType(['ArrayExpression'], function(node) {
            var els = node.elements;
            if (els.length <= maximum && node.loc.start.line === node.loc.end.line) {
                return;
            }

            if (!ignoreBrackets) {
                if (els[0] && els[0].loc.start.line === node.loc.start.line) {
                    errors.add('First element should be placed on new line', els[0].loc.start);
                }
                if (els[els.length - 1] && els[els.length - 1].loc.end.line === node.loc.end.line) {
                    errors.add('Closing bracket should be placed on new line', node.loc.end);
                }
            }

            var prevLine = 0;
            els.forEach(function(elem) {
                if (!elem) {
                    // skip holes
                    return;
                }
                var line = elem.loc.start.line;
                if (prevLine === line) {
                    errors.add('Multiple elements at a single line in multiline array', {
                        line: line,
                        column: elem.loc.start.column
                    });
                }
                prevLine = line;
            });

        });
    }
    check: function(file, errors) {
        var maximum = this._options.maximum;
        var ignoreBrackets = this._options.ignoreBrackets;
Function (anonymous_987)
✓ Was called        file.iterateNodesByType(['ArrayExpression'], function(node) {···
            var els = node.elements;
            if (els.length <= maximum && node.loc.start.line === node.loc.end.line) {
                return;
            }

            if (!ignoreBrackets) {
                if (els[0] && els[0].loc.start.line === node.loc.start.line) {
                    errors.add('First element should be placed on new line', els[0].loc.start);
                }
                if (els[els.length - 1] && els[els.length - 1].loc.end.line === node.loc.end.line) {
                    errors.add('Closing bracket should be placed on new line', node.loc.end);
                }
            }

            var prevLine = 0;
            els.forEach(function(elem) {
                if (!elem) {
                    // skip holes
                    return;
                }
                var line = elem.loc.start.line;
                if (prevLine === line) {
                    errors.add('Multiple elements at a single line in multiline array', {
                        line: line,
                        column: elem.loc.start.column
                    });
                }
                prevLine = line;
            });

        });
        file.iterateNodesByType(['ArrayExpression'], function(node) {
            var els = node.elements;
Branch IfStatement
✓ Positive was executed (if)            if (els.length <= maximum && node.loc.start.line === node.loc.end.line) {···
                return;
            }
✓ Negative was executed (else)            }···

            if (!ignoreBrackets) {
Branch LogicalExpression
✓ Was returned            if (els.length <= maximum && node.loc.start.line === node.loc.end.line) {
✓ Was returned            if (els.length <= maximum && node.loc.start.line === node.loc.end.line) {
            if (els.length <= maximum && node.loc.start.line === node.loc.end.line) {
                return;
            }
Branch IfStatement
✓ Positive was executed (if)            if (!ignoreBrackets) {···
                if (els[0] && els[0].loc.start.line === node.loc.start.line) {
                    errors.add('First element should be placed on new line', els[0].loc.start);
                }
                if (els[els.length - 1] && els[els.length - 1].loc.end.line === node.loc.end.line) {
                    errors.add('Closing bracket should be placed on new line', node.loc.end);
                }
            }
✓ Negative was executed (else)            }···

            var prevLine = 0;
            if (!ignoreBrackets) {
Branch IfStatement
✓ Positive was executed (if)                if (els[0] && els[0].loc.start.line === node.loc.start.line) {···
                    errors.add('First element should be placed on new line', els[0].loc.start);
                }
✓ Negative was executed (else)                }···
                if (els[els.length - 1] && els[els.length - 1].loc.end.line === node.loc.end.line) {
Branch LogicalExpression
✓ Was returned                if (els[0] && els[0].loc.start.line === node.loc.start.line) {
✓ Was returned                if (els[0] && els[0].loc.start.line === node.loc.start.line) {
                if (els[0] && els[0].loc.start.line === node.loc.start.line) {
                    errors.add('First element should be placed on new line', els[0].loc.start);
                }
Branch IfStatement
✓ Positive was executed (if)                if (els[els.length - 1] && els[els.length - 1].loc.end.line === node.loc.end.line) {···
                    errors.add('Closing bracket should be placed on new line', node.loc.end);
                }
✓ Negative was executed (else)                }···
            }
Branch LogicalExpression
✓ Was returned                if (els[els.length - 1] && els[els.length - 1].loc.end.line === node.loc.end.line) {
✓ Was returned                if (els[els.length - 1] && els[els.length - 1].loc.end.line === node.loc.end.line) {
                if (els[els.length - 1] && els[els.length - 1].loc.end.line === node.loc.end.line) {
                    errors.add('Closing bracket should be placed on new line', node.loc.end);
                }
            }
            var prevLine = 0;
Function (anonymous_988)
✓ Was called            els.forEach(function(elem) {···
                if (!elem) {
                    // skip holes
                    return;
                }
                var line = elem.loc.start.line;
                if (prevLine === line) {
                    errors.add('Multiple elements at a single line in multiline array', {
                        line: line,
                        column: elem.loc.start.column
                    });
                }
                prevLine = line;
            });
            els.forEach(function(elem) {
Branch IfStatement
✓ Positive was executed (if)                if (!elem) {···
                    // skip holes
                    return;
                }
✓ Negative was executed (else)                }···
                var line = elem.loc.start.line;
                if (!elem) {
                    // skip holes
                    return;
                }
                var line = elem.loc.start.line;
Branch IfStatement
✓ Positive was executed (if)                if (prevLine === line) {···
                    errors.add('Multiple elements at a single line in multiline array', {
                        line: line,
                        column: elem.loc.start.column
                    });
                }
✓ Negative was executed (else)                }···
                prevLine = line;
                if (prevLine === line) {
                    errors.add('Multiple elements at a single line in multiline array', {
                        line: line,
                        column: elem.loc.start.column
                    });
                }
                prevLine = line;
            });
        });
    }
};

disallow-not-operators-in-conditionals.js
/**
 * Disallows the not, not equals, and strict not equals operators in conditionals.
 *
 * Type: `Boolean`
 *
 * Value: `true`
 *
 * #### Example
 *
 * ```js
 * "disallowNotOperatorsInConditionals": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * if (clause) {
 *     // Do something really crazy
 * } else {
 *     // Do something crazy
 * }
 *
 * if (a == 1) {
 *     // Do something really crazy
 * } else {
 *     // Do something crazy
 * }
 *
 * var a = (clause) ? 1 : 0
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * if (!clause) {
 *     // Do something crazy
 * } else {
 *     // Do something really crazy
 * }
 *
 * if (a != 1) {
 *     // Do something crazy
 * } else {
 *     // Do something really crazy
 * }
 *
 * if (a !== 1) {
 *     // Do something crazy
 * } else {
 *     // Do something really crazy
 * }
 *
 * var a = (!clause) ? 0 : 1
 * ```
 */
var assert = require('assert');
Function (anonymous_989)
✓ Was calledmodule.exports = function() {};
module.exports = function() {};
module.exports.prototype = {
Function (anonymous_990)
✓ Was called    configure: function(options) {···
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
    configure: function(options) {
        assert(
            options === true,
            this.getOptionName() + ' option requires a true value or should be removed'
        );
    },
Function (anonymous_991)
✓ Was called    getOptionName: function() {···
        return 'disallowNotOperatorsInConditionals';
    },
    getOptionName: function() {
        return 'disallowNotOperatorsInConditionals';
    },
Function (anonymous_992)
✓ Was called    check: function(file, errors) {···
        function hasNotOperator(test) {
            return test.type === 'UnaryExpression' && test.operator === '!';
        }

        function hasNotEqualOperator(test) {
            return test.type === 'BinaryExpression' && test.operator === '!=';
        }

        function hasStrictNotEqualOperator(test) {
            return test.type === 'BinaryExpression' && test.operator === '!==';
        }

        file.iterateNodesByType(['IfStatement', 'ConditionalExpression'], function(node) {
            var alternate = node.alternate;

            // check if the if statement has an else block
            if (node.type === 'IfStatement' && (!alternate || alternate.type !== 'BlockStatement')) {
                return;
            }
            var test = node.test;
            if (hasNotOperator(test)) {
                errors.add('Illegal use of not operator in if statement', test.loc.start);
            }
            if (hasNotEqualOperator(test)) {
                errors.add('Illegal use of not equal operator in if statement', test.loc.end);
            }
            if (hasStrictNotEqualOperator(test)) {
                errors.add('Illegal use of strict not equal operator in if statement', test.loc.end);
            }
        });
    }
    check: function(file, errors) {
Function hasNotOperator
✓ Was called        function hasNotOperator(test) {···
            return test.type === 'UnaryExpression' && test.operator === '!';
        }
        function hasNotOperator(test) {
Branch LogicalExpression
✓ Was returned            return test.type === 'UnaryExpression' && test.operator === '!';
✓ Was returned            return test.type === 'UnaryExpression' && test.operator === '!';
            return test.type === 'UnaryExpression' && test.operator === '!';
        }
Function hasNotEqualOperator
✓ Was called        function hasNotEqualOperator(test) {···
            return test.type === 'BinaryExpression' && test.operator === '!=';
        }
        function hasNotEqualOperator(test) {
Branch LogicalExpression
✓ Was returned            return test.type === 'BinaryExpression' && test.operator === '!=';
✓ Was returned            return test.type === 'BinaryExpression' && test.operator === '!=';
            return test.type === 'BinaryExpression' && test.operator === '!=';
        }
Function hasStrictNotEqualOperator
✓ Was called        function hasStrictNotEqualOperator(test) {···
            return test.type === 'BinaryExpression' && test.operator === '!==';
        }
        function hasStrictNotEqualOperator(test) {
Branch LogicalExpression
✓ Was returned            return test.type === 'BinaryExpression' && test.operator === '!==';
✓ Was returned            return test.type === 'BinaryExpression' && test.operator === '!==';
            return test.type === 'BinaryExpression' && test.operator === '!==';
        }
Function (anonymous_996)
✓ Was called        file.iterateNodesByType(['IfStatement', 'ConditionalExpression'], function(node) {···
            var alternate = node.alternate;

            // check if the if statement has an else block
            if (node.type === 'IfStatement' && (!alternate || alternate.type !== 'BlockStatement')) {
                return;
            }
            var test = node.test;
            if (hasNotOperator(test)) {
                errors.add('Illegal use of not operator in if statement', test.loc.start);
            }
            if (hasNotEqualOperator(test)) {
                errors.add('Illegal use of not equal operator in if statement', test.loc.end);
            }
            if (hasStrictNotEqualOperator(test)) {
                errors.add('Illegal use of strict not equal operator in if statement', test.loc.end);
            }
        });
        file.iterateNodesByType(['IfStatement', 'ConditionalExpression'], function(node) {
            var alternate = node.alternate;
            // check if the if statement has an else block
Branch IfStatement
✓ Positive was executed (if)            if (node.type === 'IfStatement' && (!alternate || alternate.type !== 'BlockStatement')) {···
                return;
            }
✓ Negative was executed (else)            }···
            var test = node.test;
Branch LogicalExpression
✓ Was returned            if (node.type === 'IfStatement' && (!alternate || alternate.type !== 'BlockStatement')) {
✓ Was returned            if (node.type === 'IfStatement' && (!alternate || alternate.type !== 'BlockStatement')) {
Branch LogicalExpression
✓ Was returned            if (node.type === 'IfStatement' && (!alternate || alternate.type !== 'BlockStatement')) {
✓ Was returned            if (node.type === 'IfStatement' && (!alternate || alternate.type !== 'BlockStatement')) {
            if (node.type === 'IfStatement' && (!alternate || alternate.type !== 'BlockStatement')) {
                return;
            }
            var test = node.test;
Branch IfStatement
✓ Positive was executed (if)            if (hasNotOperator(test)) {···
                errors.add('Illegal use of not operator in if statement', test.loc.start);
            }
✓ Negative was executed (else)            }···
            if (hasNotEqualOperator(test)) {
            if (hasNotOperator(test)) {
                errors.add('Illegal use of not operator in if statement', test.loc.start);
            }
Branch IfStatement
✓ Positive was executed (if)            if (hasNotEqualOperator(test)) {···
                errors.add('Illegal use of not equal operator in if statement', test.loc.end);
            }
✓ Negative was executed (else)            }···
            if (hasStrictNotEqualOperator(test)) {
            if (hasNotEqualOperator(test)) {
                errors.add('Illegal use of not equal operator in if statement', test.loc.end);
            }
Branch IfStatement
✓ Positive was executed (if)            if (hasStrictNotEqualOperator(test)) {···
                errors.add('Illegal use of strict not equal operator in if statement', test.loc.end);
            }
✓ Negative was executed (else)            }···
        });
            if (hasStrictNotEqualOperator(test)) {
                errors.add('Illegal use of strict not equal operator in if statement', test.loc.end);
            }
        });
    }
};

console.js
/**
 * @param {Errors[]} errorsCollection
 */
Function (anonymous_997)
✓ Was calledmodule.exports = function(errorsCollection) {···
    var errorCount = 0;
    /**
     * Formatting every error set.
     */
    errorsCollection.forEach(function(errors) {
        if (!errors.isEmpty()) {
            /**
             * Formatting every single error.
             */
            errors.getErrorList().forEach(function(error) {
                errorCount++;
                console.log(errors.explainError(error, true) + '\n');
            });
        }
    });
    if (errorCount) {
        /**
         * Printing summary.
         */
        console.log('\n' + errorCount + ' code style ' + (errorCount === 1 ? 'error' : 'errors') + ' found.');
    } else {
        console.log('No code style errors found.');
    }
};
module.exports = function(errorsCollection) {
    var errorCount = 0;
    /**
     * Formatting every error set.
     */
Function (anonymous_998)
✓ Was called    errorsCollection.forEach(function(errors) {···
        if (!errors.isEmpty()) {
            /**
             * Formatting every single error.
             */
            errors.getErrorList().forEach(function(error) {
                errorCount++;
                console.log(errors.explainError(error, true) + '\n');
            });
        }
    });
    errorsCollection.forEach(function(errors) {
Branch IfStatement
✓ Positive was executed (if)        if (!errors.isEmpty()) {···
            /**
             * Formatting every single error.
             */
            errors.getErrorList().forEach(function(error) {
                errorCount++;
                console.log(errors.explainError(error, true) + '\n');
            });
        }
✓ Negative was executed (else)        }···
    });
        if (!errors.isEmpty()) {
            /**
             * Formatting every single error.
             */
Function (anonymous_999)
✓ Was called            errors.getErrorList().forEach(function(error) {···
                errorCount++;
                console.log(errors.explainError(error, true) + '\n');
            });
            errors.getErrorList().forEach(function(error) {
                errorCount++;
                console.log(errors.explainError(error, true) + '\n');
            });
        }
    });
Branch IfStatement
✓ Positive was executed (if)    if (errorCount) {···
        /**
         * Printing summary.
         */
        console.log('\n' + errorCount + ' code style ' + (errorCount === 1 ? 'error' : 'errors') + ' found.');
    } else {
✓ Negative was executed (else)    } else {···
        console.log('No code style errors found.');
    }
    if (errorCount) {
        /**
         * Printing summary.
         */
Branch ConditionalExpression
✓ Positive was returned (? ...)        console.log('\n' + errorCount + ' code style ' + (errorCount === 1 ? 'error' : 'errors') + ' found.');
✓ Negative was returned (: ...)        console.log('\n' + errorCount + ' code style ' + (errorCount === 1 ? 'error' : 'errors') + ' found.');
        console.log('\n' + errorCount + ' code style ' + (errorCount === 1 ? 'error' : 'errors') + ' found.');
    } else {
        console.log('No code style errors found.');
    }
};

inline.js
var util = require('util');
/**
 * @param {Errors[]} errorsCollection
 */
Function (anonymous_1000)
✓ Was calledmodule.exports = function(errorsCollection) {···
    var errorCount = 0;
    /**
     * Formatting every error set.
     */
    errorsCollection.forEach(function(errors) {
        var file = errors.getFilename();
        if (!errors.isEmpty()) {
            errors.getErrorList().forEach(function(error) {
                errorCount++;
                console.log(util.format('%s: line %d, col %d, %s', file, error.line, error.column, error.message));
            });
        }
    });
};
module.exports = function(errorsCollection) {
    var errorCount = 0;
    /**
     * Formatting every error set.
     */
Function (anonymous_1001)
✓ Was called    errorsCollection.forEach(function(errors) {···
        var file = errors.getFilename();
        if (!errors.isEmpty()) {
            errors.getErrorList().forEach(function(error) {
                errorCount++;
                console.log(util.format('%s: line %d, col %d, %s', file, error.line, error.column, error.message));
            });
        }
    });
    errorsCollection.forEach(function(errors) {
        var file = errors.getFilename();
Branch IfStatement
✓ Positive was executed (if)        if (!errors.isEmpty()) {···
            errors.getErrorList().forEach(function(error) {
                errorCount++;
                console.log(util.format('%s: line %d, col %d, %s', file, error.line, error.column, error.message));
            });
        }
✓ Negative was executed (else)        }···
    });
        if (!errors.isEmpty()) {
Function (anonymous_1002)
✓ Was called            errors.getErrorList().forEach(function(error) {···
                errorCount++;
                console.log(util.format('%s: line %d, col %d, %s', file, error.line, error.column, error.message));
            });
            errors.getErrorList().forEach(function(error) {
                errorCount++;
                console.log(util.format('%s: line %d, col %d, %s', file, error.line, error.column, error.message));
            });
        }
    });
};

inlinesingle.js
/**
 * inlinesingle solves an issue that Windows (7+) users have been
 * experiencing using SublimeLinter-jscs. It appears this is due to
 * SublimeText not managing multi-line output properly on these machines.
 * This reporter differs from inline.js by producing one comment line
 * separated by linebreaks rather than a series of separate lines.
 */
var util = require('util');
/**
 * @param {Errors[]} errorsCollection
 */
Function (anonymous_1003)
✓ Was calledmodule.exports = function(errorsCollection) {···
    errorsCollection.forEach(function(errors) {
        if (!errors.isEmpty()) {
            var file = errors.getFilename();
            var out = errors.getErrorList().map(function(error) {
                return util.format('%s: line %d, col %d, %s', file, error.line, error.column, error.message);
            });
            console.log(out.join('\n'));
        }
    });
};
module.exports = function(errorsCollection) {
Function (anonymous_1004)
✓ Was called    errorsCollection.forEach(function(errors) {···
        if (!errors.isEmpty()) {
            var file = errors.getFilename();
            var out = errors.getErrorList().map(function(error) {
                return util.format('%s: line %d, col %d, %s', file, error.line, error.column, error.message);
            });
            console.log(out.join('\n'));
        }
    });
    errorsCollection.forEach(function(errors) {
Branch IfStatement
✓ Positive was executed (if)        if (!errors.isEmpty()) {···
            var file = errors.getFilename();
            var out = errors.getErrorList().map(function(error) {
                return util.format('%s: line %d, col %d, %s', file, error.line, error.column, error.message);
            });
            console.log(out.join('\n'));
        }
✓ Negative was executed (else)        }···
    });
        if (!errors.isEmpty()) {
            var file = errors.getFilename();
Function (anonymous_1005)
✓ Was called            var out = errors.getErrorList().map(function(error) {···
                return util.format('%s: line %d, col %d, %s', file, error.line, error.column, error.message);
            });
            var out = errors.getErrorList().map(function(error) {
                return util.format('%s: line %d, col %d, %s', file, error.line, error.column, error.message);
            });
            console.log(out.join('\n'));
        }
    });
};

junit.js
var xml = require('xmlbuilder');
Function (anonymous_1006)
✓ Was calledmodule.exports = function(errorCollection) {···
    var i = 0;
    var testsuite = xml.create('testsuite');

    testsuite.att('name', 'JSCS');
    testsuite.att('tests', errorCollection.length);

    errorCollection.forEach(function(errors) {
        var errorsCount = errors.getErrorCount();
        var testcase = testsuite.ele('testcase', {
            name: errors.getFilename(),
            failures: errorsCount
        });

        i += errorsCount;

        errors.getErrorList().forEach(function(error) {
            testcase.ele('failure', {}, errors.explainError(error));
        });
    });

    testsuite.att('failures', i);

    console.log(testsuite.end({pretty: true}));
};
module.exports = function(errorCollection) {
    var i = 0;
    var testsuite = xml.create('testsuite');
    testsuite.att('name', 'JSCS');
    testsuite.att('tests', errorCollection.length);
Function (anonymous_1007)
✓ Was called    errorCollection.forEach(function(errors) {···
        var errorsCount = errors.getErrorCount();
        var testcase = testsuite.ele('testcase', {
            name: errors.getFilename(),
            failures: errorsCount
        });

        i += errorsCount;

        errors.getErrorList().forEach(function(error) {
            testcase.ele('failure', {}, errors.explainError(error));
        });
    });
    errorCollection.forEach(function(errors) {
        var errorsCount = errors.getErrorCount();
        var testcase = testsuite.ele('testcase', {
            name: errors.getFilename(),
            failures: errorsCount
        });
        i += errorsCount;
Function (anonymous_1008)
✓ Was called        errors.getErrorList().forEach(function(error) {···
            testcase.ele('failure', {}, errors.explainError(error));
        });
        errors.getErrorList().forEach(function(error) {
            testcase.ele('failure', {}, errors.explainError(error));
        });
    });
    testsuite.att('failures', i);
    console.log(testsuite.end({pretty: true}));
};

text.js
/**
 * @param {Errors[]} errorsCollection
 */
Function (anonymous_1009)
✓ Was calledmodule.exports = function(errorsCollection) {···
    var errorCount = 0;
    /**
     * Formatting every error set.
     */
    errorsCollection.forEach(function(errors) {
        if (!errors.isEmpty()) {
            /**
             * Formatting every single error.
             */
            errors.getErrorList().forEach(function(error) {
                errorCount++;
                console.log(errors.explainError(error) + '\n');
            });
        }
    });
    if (errorCount) {
        /**
         * Printing summary.
         */
        console.log('\n' + errorCount + ' code style ' + (errorCount === 1 ? 'error' : 'errors') + ' found.');
    } else {
        console.log('No code style errors found.');
    }
};
module.exports = function(errorsCollection) {
    var errorCount = 0;
    /**
     * Formatting every error set.
     */
Function (anonymous_1010)
✓ Was called    errorsCollection.forEach(function(errors) {···
        if (!errors.isEmpty()) {
            /**
             * Formatting every single error.
             */
            errors.getErrorList().forEach(function(error) {
                errorCount++;
                console.log(errors.explainError(error) + '\n');
            });
        }
    });
    errorsCollection.forEach(function(errors) {
Branch IfStatement
✓ Positive was executed (if)        if (!errors.isEmpty()) {···
            /**
             * Formatting every single error.
             */
            errors.getErrorList().forEach(function(error) {
                errorCount++;
                console.log(errors.explainError(error) + '\n');
            });
        }
✓ Negative was executed (else)        }···
    });
        if (!errors.isEmpty()) {
            /**
             * Formatting every single error.
             */
Function (anonymous_1011)
✓ Was called            errors.getErrorList().forEach(function(error) {···
                errorCount++;
                console.log(errors.explainError(error) + '\n');
            });
            errors.getErrorList().forEach(function(error) {
                errorCount++;
                console.log(errors.explainError(error) + '\n');
            });
        }
    });
Branch IfStatement
✓ Positive was executed (if)    if (errorCount) {···
        /**
         * Printing summary.
         */
        console.log('\n' + errorCount + ' code style ' + (errorCount === 1 ? 'error' : 'errors') + ' found.');
    } else {
✓ Negative was executed (else)    } else {···
        console.log('No code style errors found.');
    }
    if (errorCount) {
        /**
         * Printing summary.
         */
Branch ConditionalExpression
✓ Positive was returned (? ...)        console.log('\n' + errorCount + ' code style ' + (errorCount === 1 ? 'error' : 'errors') + ' found.');
✓ Negative was returned (: ...)        console.log('\n' + errorCount + ' code style ' + (errorCount === 1 ? 'error' : 'errors') + ' found.');
        console.log('\n' + errorCount + ' code style ' + (errorCount === 1 ? 'error' : 'errors') + ' found.');
    } else {
        console.log('No code style errors found.');
    }
};

Branch LogicalExpression
✓ Was returned	filename = filename \|\| 'input';
✓ Was returned	filename = filename \|\| 'input';

Branch IfStatement
✓ Positive was executed (if)	if (this._maxErrorsExceeded) {··· return errors; }
✓ Negative was executed (else)	}··· if (parseError) {

Branch IfStatement
✓ Positive was executed (if)	if (parseError) {··· this._addParseError(errors, parseError); return errors; }
✓ Negative was executed (else)	}··· this._checkJsFile(file, errors);

Function (anonymous_36)
✓ Was called	this._configuration.getUnsupportedRuleNames().forEach(function(rulename) {··· errors.add('Unsupported rule: ' + rulename, 1, 0); });

Function (anonymous_37)
✓ Was called	errors.getErrorList().sort(function(a, b) {··· return (a.line - b.line) \|\| (a.column - b.column); });

Branch LogicalExpression
✓ Was returned	return (a.line - b.line) \|\| (a.column - b.column);
✓ Was returned	return (a.line - b.line) \|\| (a.column - b.column);

Branch IfStatement
✓ Positive was executed (if)	if (errorFilter) {··· errors.filter(errorFilter); }
✓ Negative was executed (else)	}··· if (this._maxErrorsEnabled()) {

Branch IfStatement
✓ Positive was executed (if)	if (this._maxErrorsEnabled()) {··· this._maxErrorsExceeded = this._errorsFound + errors.getErrorCount() > this._maxErrors; errors.stripErrorList(Math.max(0, this._maxErrors - this._errorsFound)); }
✓ Negative was executed (else)	}··· this._errorsFound += errors.getErrorCount();

Function (anonymous_38)
✓ Was called	_addParseError: function(errors, parseError) {··· if (this._maxErrorsExceeded) { return; } errors.setCurrentRule('parseError'); errors.add(parseError.description, parseError.lineNumber, parseError.column); if (this._maxErrorsEnabled()) { this._errorsFound += 1; this._maxErrorsExceeded = this._errorsFound >= this._maxErrors; } },

Function (anonymous_39)
✓ Was called	_createJsFileInstance: function(filename, source, sourceTree) {··· return new JsFile(filename, source, sourceTree, { es3: this._configuration.isES3Enabled(), es6: this._configuration.isESNextEnabled() }); },

Branch IfStatement
✗ Positive was not executed (if)	if (this._maxErrorsEnabled()) {··· throw new Error('Cannot autofix when `maxError` option is enabled'); }
✓ Negative was executed (else)	}··· filename = filename \|\| 'input';

Branch IfStatement
✓ Positive was executed (if)	if (parseError) {··· var parseErrors = new Errors(this._createJsFileInstance(filename, source, sourceTree), this._verbose); this._addParseError(parseErrors, parseError); return {output: source, errors: parseErrors}; } else {
✓ Negative was executed (else)	} else {··· var attempt = 0; var errors; var file; do { file = this._createJsFileInstance(filename, source, sourceTree); errors = new Errors(file, this._verbose); // Changes to current sources are made in rules through assertions. this._checkJsFile(file, errors); var hasFixes = errors.getErrorList().some(function(err) { return err.fixed; }); if (!hasFixes) { break; } source = file.render(); sourceTree = JsFile.parse(source, this._esprima, this._configuration.getEsprimaOptions()); attempt++; } while (attempt < MAX_FIX_ATTEMPTS); return {output: source, errors: errors}; }

Function (anonymous_41)
✓ Was called	var hasFixes = errors.getErrorList().some(function(err) {··· return err.fixed; });

Branch IfStatement
✓ Positive was executed (if)	if (!hasFixes) {··· break; }
✓ Negative was executed (else)	}··· source = file.render();

Function (anonymous_42)
✓ Was called	_maxErrorsEnabled: function() {··· return this._maxErrors !== null && !isNaN(this._maxErrors); },

Branch LogicalExpression
✓ Was returned	return this._maxErrors !== null && !isNaN(this._maxErrors);
✓ Was returned	return this._maxErrors !== null && !isNaN(this._maxErrors);

Function (anonymous_43)
✗ Was not called	maxErrorsExceeded: function() {··· return this._maxErrorsExceeded; },

Function (anonymous_44)
✓ Was called	_createConfiguration: function() {··· return new Configuration(); },

Function (anonymous_45)
✗ Was not called	getConfiguration: function() {··· return this._configuration; }

Function (anonymous_46)
✓ Was called	var Errors = function(file, verbose) {··· this._errorList = []; this._file = file; this._currentRule = ''; this._verbose = verbose \|\| false; /** * @type {TokenAssert} * @public */ this.assert = new TokenAssert(file); this.assert.on('error', this._addError.bind(this)); };

Branch LogicalExpression
✓ Was returned	this._verbose = verbose \|\| false;
✓ Was returned	this._verbose = verbose \|\| false;

Branch IfStatement
✓ Positive was executed (if)	if (typeof line === 'object') {··· column = line.column; line = line.line; }
✓ Negative was executed (else)	}··· // line and column numbers should be explicit

Branch LogicalExpression
✓ Was returned	assert(typeof line === 'number' && line > 0,
✓ Was returned	assert(typeof line === 'number' && line > 0,

Branch LogicalExpression
✓ Was returned	assert(typeof column === 'number' && column >= 0,
✓ Was returned	assert(typeof column === 'number' && column >= 0,

Function (anonymous_48)
✓ Was called	_addError: function(errorInfo) {··· if (!this._file.isEnabledRule(this._currentRule, errorInfo.line)) { return; } this._errorList.push({ filename: this._file.getFilename(), rule: this._currentRule, message: this._prepareMessage(errorInfo), line: errorInfo.line, column: errorInfo.column, fixed: errorInfo.fixed }); },

Branch IfStatement
✓ Positive was executed (if)	if (!this._file.isEnabledRule(this._currentRule, errorInfo.line)) {··· return; }
✓ Negative was executed (else)	}··· this._errorList.push({

Function (anonymous_49)
✓ Was called	_prepareMessage: function(errorInfo) {··· if (this._verbose && this._currentRule) { return this._currentRule + ': ' + errorInfo.message; } return errorInfo.message; },

Branch IfStatement
✓ Positive was executed (if)	if (this._verbose && this._currentRule) {··· return this._currentRule + ': ' + errorInfo.message; }
✓ Negative was executed (else)	}··· return errorInfo.message;

Branch LogicalExpression
✓ Was returned	if (this._verbose && this._currentRule) {
✓ Was returned	if (this._verbose && this._currentRule) {

Function (anonymous_50)
✓ Was called	getErrorList: function() {··· return this._errorList; },

Function (anonymous_51)
✓ Was called	getFilename: function() {··· return this._file.getFilename(); },